Show Menu
TEMAS×

Guía del usuario de JupyterLab

JupyterLab es una interfaz de usuario basada en web para Project Jupyter y está estrechamente integrada en Adobe Experience Platform. Proporciona un entorno de desarrollo interactivo para que los científicos de datos trabajen con portátiles Jupyter, código y datos.
Este documento proporciona información general sobre JupyterLab y sus características, así como instrucciones para realizar acciones comunes.

JupyterLab en la plataforma de experiencia

La integración de JupyterLab de la plataforma de experiencia se acompaña de cambios en la arquitectura, consideraciones de diseño, extensiones de bloc de notas personalizadas, bibliotecas preinstaladas y una interfaz temática de Adobe.
La siguiente lista describe algunas de las características exclusivas de JupyterLab en la plataforma:
Función
Descripción
Kernels
Los Kernels proporcionan al portátil y a otros front-end de JupyterLab la capacidad de ejecutar e introducir código en diferentes lenguajes de programación. La plataforma de experiencias proporciona núcleos adicionales para admitir el desarrollo en Python, R, PySpark y Spark. Consulte la sección kernels para obtener más detalles.
Acceso a datos
Acceda directamente a los conjuntos de datos existentes desde JupyterLab con compatibilidad total con funciones de lectura y escritura.
Integración de servicios de plataforma
Las integraciones integradas le permiten utilizar otros servicios de plataforma directamente desde JupyterLab. En la sección sobre Integración con otros servicios de la Plataforma se proporciona una lista completa de las integraciones admitidas.
Autenticación
Además del modelo security.html de seguridad integrado deJupyterLab, todas las interacciones entre la aplicación y la plataforma de experiencia, incluida la comunicación entre servicio y servicio de plataforma, se cifran y autentican a través del auth-methods.html Adobe Identity Management System (IMS).
Bibliotecas de desarrollo
En la plataforma de experiencia, JupyterLab proporciona bibliotecas preinstaladas para Python, R y PySpark. Consulte el apéndice para obtener una lista completa de las bibliotecas admitidas.
Controlador de biblioteca
Cuando las bibliotecas preinstaladas no están disponibles para sus necesidades, se pueden instalar bibliotecas adicionales para Python y R, y se almacenan temporalmente en contenedores aislados para mantener la integridad de Platform y mantener los datos seguros. Consulte la sección kernels para obtener más detalles.
Las bibliotecas adicionales solo están disponibles para la sesión en la que se instalaron. Debe reinstalar las bibliotecas adicionales que necesite al iniciar sesiones nuevas.

Integración con otros servicios de plataforma

La estandarización y la interoperabilidad son conceptos clave que sustentan Experience Platform. La integración de JupyterLab en Platform un IDE integrado le permite interactuar con otros Platform servicios, permitiéndole aprovechar Platform al máximo su potencial. Los siguientes Platform servicios están disponibles en JupyterLab:
  • Servicio de catálogo: Acceda y explore conjuntos de datos con funcionalidades de lectura y escritura.
  • Servicio de Consulta: Acceda y explore conjuntos de datos mediante SQL, proporcionando un acceso a los datos más bajo en los costes generales cuando se trata de grandes cantidades de datos.
  • Marco para la detección del lenguaje Sensei ML: Desarrollo de modelos con la capacidad de entrenar y marcar datos, así como la creación de fórmulas con un solo clic.
  • Modelo de datos de experiencia (XDM): La estandarización y la interoperabilidad son conceptos clave que subyacen a Adobe Experience Platform. El modelo de datos de experiencia (XDM) , dirigido por Adobe, es un esfuerzo para estandarizar los datos de experiencia del cliente y definir esquemas para la administración de la experiencia del cliente.
Algunas integraciones Platform de servicio en JupyterLab están limitadas a núcleos específicos. Consulte la sección sobre núcleos para obtener más detalles.

Funciones clave y operaciones comunes

En las secciones siguientes encontrará información sobre las características clave de JupyterLab e instrucciones sobre cómo realizar operaciones comunes:

Access JupyterLab

En Adobe Experience Platform , seleccione Equipos portátiles en la columna de navegación izquierda. Deje tiempo para que JupyterLab se inicialice completamente.

Interfaz JupyterLab

La interfaz de JupyterLab consta de una barra de menús, una barra lateral izquierda contraíble y el área de trabajo principal que contiene fichas de documentos y actividades.
Barra de menús
La barra de menús situada en la parte superior de la interfaz tiene menús de nivel superior que exponen las acciones disponibles en JupyterLab con sus métodos abreviados de teclado:
  • Archivo: Acciones relacionadas con archivos y directorios
  • Editar: Acciones relacionadas con la edición de documentos y otras actividades
  • Vista: Acciones que alteran la apariencia de JupyterLab
  • Ejecutar: Acciones para ejecutar código en diferentes actividades, como blocs de notas y consolas de código
  • Núcleo: Acciones para administrar los núcleos
  • Fichas: Una lista de documentos y actividades abiertos
  • Configuración: Configuración común y editor de configuración avanzada
  • Ayuda: Una lista de JupyterLab y enlaces de ayuda del núcleo
Barra lateral izquierda
La barra lateral izquierda contiene fichas en las que se puede hacer clic que proporcionan acceso a las siguientes funciones:
  • Explorador de archivos: Una lista de documentos y directorios de portátiles guardados
  • Explorador de datos: Examinar, acceder y explorar conjuntos de datos y esquemas
  • Kernels de funcionamiento y terminales: Una lista de las sesiones activas del núcleo y de terminal con la capacidad de finalizar
  • Comandos: Una lista de comandos útiles
  • Inspector de celdas: Editor de celdas que proporciona acceso a herramientas y metadatos útiles para configurar un bloc de notas con fines de presentación
  • fichas: Una lista de fichas abiertas
Haga clic en una ficha para exponer sus funciones o haga clic en una ficha expandida para contraer la barra lateral izquierda como se muestra a continuación:
Área de trabajo principal
El área de trabajo principal de JupyterLab le permite organizar documentos y otras actividades en paneles de fichas que se pueden cambiar de tamaño o subdividir. Arrastre una ficha al centro de un panel de fichas para migrarla. Para dividir un panel, arrastre una ficha a la izquierda, a la derecha, a la parte superior o a la parte inferior del panel:

Celdas de código

Las celdas de código son el contenido principal de los blocs de notas. Contienen código fuente en el idioma del núcleo asociado al bloc de notas y la salida como resultado de la ejecución de la celda de código. Se muestra un recuento de ejecución a la derecha de cada celda de código que representa su orden de ejecución.
Las acciones comunes de las células se describen a continuación:
  • Añadir una celda: Haga clic en el símbolo más ( + ) del menú del bloc de notas para agregar una celda vacía. Las celdas nuevas se colocan debajo de la celda con la que se está interactuando o al final del bloc de notas si no hay ninguna celda en particular enfocada.
  • Mover una celda: Sitúe el cursor a la derecha de la celda que desee mover y, a continuación, haga clic y arrastre la celda a una nueva ubicación. Además, al mover una celda de un bloc de notas a otro se replica la celda junto con su contenido.
  • Ejecutar una celda: Haga clic en el cuerpo de la celda que desee ejecutar y, a continuación, haga clic en el icono de reproducción ( ) en el menú del bloc de notas. Se muestra un asterisco ( * ) en el contador de ejecución de la celda cuando el núcleo está procesando la ejecución y se reemplaza por un entero al finalizar.
  • Eliminar una celda: Haga clic en el cuerpo de la celda que desee eliminar y, a continuación, haga clic en el icono de la tijera .

Kernels

Los núcleos de los portátiles son los motores informáticos específicos del idioma para procesar las celdas de los portátiles. Además de Python, JupyterLab proporciona soporte de idioma adicional en R, PySpark y Spark (Scala). Al abrir un documento portátil, se inicia el núcleo asociado. Cuando se ejecuta una celda portátil, el núcleo realiza el cálculo y produce resultados que pueden consumir recursos significativos de CPU y memoria. Tenga en cuenta que la memoria asignada no se libera hasta que se cierre el núcleo.
Algunas funciones y características se limitan a determinados núcleos, como se describe en la tabla siguiente:
Kernel
Compatibilidad con la instalación de la biblioteca
Integraciones de plataformas
Python
  • Marco para el transporte marítimo de Sensei ML
  • Servicio de catálogo
  • Servicio de Consulta
R
  • Marco para el transporte marítimo de Sensei ML
  • Servicio de catálogo
Scala
No
  • Marco para el transporte marítimo de Sensei ML
  • Servicio de catálogo

Sesiones de núcleo

Cada portátil o actividad activa en JupyterLab utiliza una sesión del núcleo. Todas las sesiones activas se pueden encontrar expandiendo la ficha Terminales de ejecución y núcleos desde la barra lateral izquierda. El tipo y estado del núcleo para un portátil se puede identificar observando la parte superior derecha de la interfaz del bloc de notas. En el diagrama siguiente, el núcleo asociado al bloc de notas es Python 3 y su estado actual está representado por un círculo gris a la derecha. Un círculo hueco implica un núcleo de ralentí y un círculo sólido implica un núcleo ocupado.
Si el núcleo está apagado o inactivo durante un período prolongado, entonces ¡ Sin núcleo! con un círculo sólido. Active un núcleo haciendo clic en el estado del núcleo y seleccionando el tipo de núcleo apropiado como se muestra a continuación:

Iniciador

El iniciador personalizado le proporciona plantillas de bloc de notas útiles para sus núcleos admitidos que le ayudarán a iniciar su tarea, como:
Plantilla
Descripción
En blanco
Un archivo de bloc de notas vacío.
Inicio
Un bloc de notas precargado que muestra la exploración de datos mediante datos de ejemplo.
Ventas minoristas
Un bloc de notas previamente rellenado que presenta la fórmula 2wOgO3L de venta al por menor utilizando datos de ejemplo.
Generador de fórmulas
Una plantilla de portátil para crear una fórmula en JupyterLab. Se rellena previamente con código y comentarios que muestran y describen el proceso de creación de fórmulas. Consulte el tutorial data-science-create-recipe-notebook-tutorial-en de fórmula del bloc de notas para obtener un tutorial detallado.
Servicio de Consulta
Un bloc de notas precargado que muestra el uso del servicio de Consulta directamente en JupyterLab con flujos de trabajo de muestra proporcionados que analizan los datos a escala.
Eventos XDM
Un bloc de notas precargado que muestra la exploración de datos en datos de Evento de experiencias con valor posterior, centrado en características comunes en la estructura de datos.
Consultas XDM
Un bloc de notas precargado que muestra consultas empresariales de muestra sobre los datos de Experience Evento.
Agregación
Un bloc de notas precargado que muestra flujos de trabajo de muestra a grandes cantidades acumuladas de datos en trozos más pequeños y manejables.
Clúster
Un bloc de notas precargado que muestra el proceso de modelado integral del aprendizaje automático mediante algoritmos de agrupamiento.
Algunas plantillas de bloc de notas están limitadas a ciertos núcleos. La disponibilidad de plantillas para cada núcleo se asigna en la siguiente tabla:
En blanco Inicio Ventas minoristas Generador de fórmulas Servicio de Consulta Eventos XDM Consultas XDM Agregación Clúster
Python no no no
R no no no no no no
PySpark 3 (Spark 2.4) no no no no no no
Scala no no no no no no
Para abrir un nuevo iniciador , haga clic en Archivo > Nuevo iniciador . También puede expandir el navegador de archivos desde la barra lateral izquierda y hacer clic en el símbolo más ( + ):

Acceso a los datos de la plataforma mediante equipos portátiles

Cada núcleo soportado proporciona funcionalidades integradas que le permiten leer datos de la Plataforma desde un conjunto de datos dentro de un bloc de notas. Sin embargo, la compatibilidad con la paginación de datos está limitada a los portátiles Python y R.

Límites de datos de equipos portátiles

La siguiente información define la cantidad máxima de datos que se pueden leer, qué tipo de datos se han utilizado y el intervalo de tiempo estimado que se tarda en leer los datos. Para Python y R, se utilizó un servidor portátil configurado con 40 GB de RAM para los análisis de rendimiento. Para PySpark y Scala, se utilizó un clúster de databricks configurado en 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 esquema de ExperienceEvent utilizados varían en tamaño desde mil (1K) filas hasta mil millones (1B). Tenga en cuenta que para las métricas PySpark y Spark se utilizó un período de 10 días para los datos XDM.
Los datos de esquema específicos se preprocesaron mediante la opción Crear tabla como selección (CTAS) del servicio de Consulta. Estos datos también variaron en el tamaño desde mil filas (1K) hasta mil millones (1B).

Límites de datos de portátiles Python

esquema de ExperienceEvent XDM: Debería poder leer un máximo de 2 millones de filas (aproximadamente 6,1 GB de datos en disco) de datos XDM en menos de 22 minutos. Añadir filas adicionales puede provocar errores.
Número de filas
1K
10K
100K
1M
2M
Tamaño en disco (MB)
18.73
187.5
308
3000
6050
SDK (en segundos)
20.3
86.8
63
659
1315
esquema ad-hoc: Debería poder leer un máximo de 5 millones de filas (unos 5,6 GB de datos en disco) de datos no XDM (ad-hoc) en menos de 14 minutos. Añadir filas adicionales puede provocar errores.
Número de filas
1K
10K
100K
1M
2M
3M
5M
Tamaño en disco (en MB)
1.21
11.72
115
1120
2250
3380
5630
SDK (en segundos)
7.27
9.04
27.3
180
346
487
819

Límites de datos del portátil R

esquema de ExperienceEvent XDM: Debería poder leer un máximo de 1 millón de filas de datos XDM (datos de 3 GB en disco) en menos de 13 minutos.
Número de filas
1K
10K
100K
1M
Tamaño en disco (MB)
18.73
187.5
308
3000
Núcleo R (en segundos)
14.03
69.6
86.8
775
esquema ad-hoc: Debería poder leer un máximo de 3 millones de filas de datos ad-hoc (datos de 293 MB en disco) en unos 10 minutos.
Número de filas
1K
10K
100K
1M
2M
3M
Tamaño en disco (en MB)
0.082
0.612
9.0
91
188
293
SDK R (en segundos)
7.7
4.58
35.9
233
470.5
603

Límites de datos de portátiles PySpark (núcleo Python):

esquema de ExperienceEvent XDM: En el modo interactivo, debe poder leer un máximo de 5 millones de filas (unos 13,42 GB de datos en disco) de datos XDM en unos 20 minutos. El modo interactivo solo admite hasta 5 millones de filas. Si desea leer conjuntos de datos más grandes, se sugiere cambiar al modo Lote. En el modo Lote, debería poder leer un máximo de 500 millones de filas (unos 1,31 TB de datos en disco) de datos XDM en unas 14 horas.
Número de filas
1K
10K
100K
1M
2M
3M
5M
10M
50M
100M
500M
Tamaño en disco
2.93MB
4.38MB
29.02
2.69 GB
5.39 GB
8.09 GB
13.42 GB
26.82 GB
134.24 GB
268.39 GB
1.31TB
SDK (modo interactivo)
33s
32.4s
55.1s
253.5s
489.2s
729.6s
1206.8s
-
-
-
-
SDK (modo Lote)
815.8s
492.8s
379.1s
637.4s
624.5s
869.2s
1104.1s
1786s
5387.2s
10624.6s
50547s
esquema ad-hoc: En el modo interactivo, debe poder leer un máximo de mil millones de filas (unos 1,05 TB de datos en disco) de datos que no sean XDM en menos de 3 minutos. En el modo Lote, debería poder leer un máximo de mil millones de filas (unos 1,05 TB de datos en disco) de datos que no sean XDM en unos 18 minutos.
Número de filas
1K
10K
100K
1M
2M
3M
5M
10M
50M
100M
500M
1B
Tamaño en disco
1.12MB
11.24MB
109.48MB
2.69 GB
2.14 GB
3.21 GB
5.36 GB
10.71 GB
53.58 GB
107.52 GB
535.88 GB
1.05TB
Modo interactivo de SDK (en segundos)
28.2s
18.6s
20.8s
20.9s
23.8s
21.7s
24.7s
22s
28.4s
40s
97.4s
154.5s
Modo de lotes de SDK (en segundos)
428.8s
578.8s
641.4s
538.5s
630.9s
467.3s
411s
675s
702s
719.2s
1022.1s
1122.3s

Límites de datos de portátiles Spark (kernel Scala):

esquema de ExperienceEvent XDM: En el modo interactivo, debe poder leer un máximo de 5 millones de filas (unos 13,42 GB de datos en 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 sugiere cambiar al modo Lote. En el modo Lote, debería poder leer un máximo de 500 millones de filas (unos 1,31 TB de datos en disco) de datos XDM en unas 14 horas.
Número de filas
1K
10K
100K
1M
2M
3M
5M
10M
50M
100M
500M
Tamaño en disco
2.93MB
4.38MB
29.02
2.69 GB
5.39 GB
8.09 GB
13.42 GB
26.82 GB
134.24 GB
268.39 GB
1.31TB
Modo interactivo de SDK (en segundos)
37.9s
22.7s
45.6s
231.7s
444.7s
660.6s
1100s
-
-
-
-
Modo de lotes de SDK (en segundos)
374.4s
398.5s
527s
487.9s
588.9s
829s
939.1s
1441s
5473.2s
10118.8
49207.6
esquema ad-hoc: En el modo interactivo, debe poder leer un máximo de mil millones de filas (unos 1,05 TB de datos en disco) de datos que no sean XDM en menos de 3 minutos. En el modo Lote, debería poder leer un máximo de mil millones de filas (unos 1,05 TB de datos en disco) de datos que no sean XDM en unos 16 minutos.
Número de filas
1K
10K
100K
1M
2M
3M
5M
10M
50M
100M
500M
1B
Tamaño en disco
1.12MB
11.24MB
109.48MB
2.69 GB
2.14 GB
3.21 GB
5.36 GB
10.71 GB
53.58 GB
107.52 GB
535.88 GB
1.05TB
Modo interactivo de SDK (en segundos)
35.7s
31s
19.5s
25.3s
23s
33.2s
25.5s
29.2s
29.7s
36.9s
83.5s
139s
Modo de lotes de SDK (en segundos)
448.8s
459.7s
519s
475.8s
599.9s
347.6s
407.8s
397s
518.8s
487.9s
760.2s
975.4s

Leer desde un conjunto de datos en Python/R

Los blocs de notas Python y R permiten paginar datos al acceder a conjuntos de datos. A continuación se muestra el código de muestra para leer datos con o sin paginación.

Leer desde un conjunto de datos en Python/R 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 nombre de datos de Pandas al que la variable hace referencia df .
# Python

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

# R

library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
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(client_context, "{DATASET_ID}") 
df <- dataset_reader$read() 
df

  • {DATASET_ID} :: Identidad única del conjunto de datos al que se accede

Leer desde un conjunto de datos en Python/R 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 se refiere al número máximo de puntos de datos que se van a leer, mientras que la compensación se refiere al número de puntos de datos que se deben omitir antes de leer los datos. Si la operación de lectura se ejecuta correctamente, los datos se guardarán como un juego de datos de Pandas al que hace referencia la variable df .
# Python

client_context = PLATFORM_SDK_CLIENT_CONTEXT
from platform_sdk.dataset_reader import DatasetReader

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

# R

library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
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(client_context, "{DATASET_ID}") 
df <- dataset_reader$limit(100L)$offset(10L)$read() 

  • {DATASET_ID} :: Identidad única del conjunto de datos al que se accede

Leer desde un conjunto de datos en PySpark/Spark/Scala

Con un bloc de notas PySpark o Scala activo abierto, expanda la ficha Explorador de datos desde la barra lateral izquierda y haga clic en Conjuntos de datos para vista de una lista de conjuntos de datos disponibles. Haga clic con el botón derecho en la lista de conjuntos de datos a la que desea acceder y haga clic en Explorar datos en el bloc de notas . Se generan las siguientes celdas de código:

PySpark (Spark 2.4)

Con la introducción de Spark 2.4, se proporciona %dataset magia personalizada.
# PySpark 3 (Spark 2.4)

%dataset read --datasetId {DATASET_ID} --dataFrame pd0
pd0.describe()
pd0.show(10, False)

Scala (Spark 2.4)

// Scala (Spark 2.4)

// initialize the session
import org.apache.spark.sql.{Dataset, SparkSession}
val spark = SparkSession.builder().master("local").getOrCreate()

val dataFrame = spark.read.format("com.adobe.platform.query")
    .option("user-token", sys.env("PYDASDK_IMS_USER_TOKEN"))
    .option("ims-org", sys.env("IMS_ORG_ID"))
    .option("api-key", sys.env("PYDASDK_IMS_CLIENT_ID"))
    .option("service-token", sys.env("PYDASDK_IMS_SERVICE_TOKEN"))
    .option("mode", "batch")
    .option("dataset-id", "{DATASET_ID}")
    .load()
dataFrame.printSchema()
dataFrame.show()

En Scala, puede utilizar sys.env() para declarar y devolver un valor desde dentro option .

Uso de la magia de %dataset en portátiles PySpark 3 (Spark 2.4)

Con la introducción de Spark 2.4, %dataset la magia personalizada se suministra para su uso en los nuevos portátiles PySpark 3 (Spark 2.4) (núcleo Python 3).
Uso
%dataset {action} --datasetId {id} --dataFrame {df}
Descripción
Un comando mágico personalizado de Data Science Workspace para leer o escribir un conjunto de datos desde un bloc de notas Python (núcleo Python 3).
  • : Tipo de acción que se realizará en el conjunto de datos. Hay dos acciones disponibles: "lectura" o "escritura".
  • —datasetId : Se utiliza para proporcionar la identificación del conjunto de datos que se va a leer o escribir. Este es un argumento requerido.
  • —dataFrame : El juego de datos pandas. Este es un argumento requerido.
    • Cuando la acción es "leída", es la variable donde están disponibles los resultados de la operación de lectura del conjunto de datos.
    • Cuando la acción es "write", este dataframe se escribe en el conjunto de datos.
  • —mode (opcional) : Los parámetros permitidos son "batch" e "interactive". De forma predeterminada, el modo se establece en "interactivo". Se recomienda utilizar el modo "por lotes" al leer grandes cantidades de datos.
Ejemplos
  • Leer ejemplo : %dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0
  • Ejemplo de escritura: %dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0

Datos de Consulta mediante el servicio de Consulta en Python

JupyterLab en plataforma le permite utilizar SQL en un bloc de notas Python para acceder a los datos a través del servicio query-service-home-en de Consulta de la plataforma deAdobe Experience Platform. El acceso a los datos a través del servicio de Consulta puede ser útil para tratar grandes conjuntos de datos debido a sus tiempos de ejecución superiores. Tenga en cuenta que la consulta de datos mediante el servicio de Consulta tiene un límite de tiempo de procesamiento de diez minutos.
Antes de usar el servicio de Consulta en JupyterLab, asegúrese de comprender bien la sintaxis query-service-sql-syntax-en SQL del servicio deConsulta.
La consulta de datos mediante el servicio de Consulta requiere que proporcione el nombre del conjunto de datos de destinatario. Puede generar las celdas de código necesarias buscando el conjunto de datos deseado mediante el explorador de datos . Haga clic con el botón secundario en la lista de conjuntos de datos y haga clic en Datos de Consulta en el bloc de notas para generar las dos celdas de código siguientes en el bloc de notas:
Para utilizar el servicio de Consulta en JupyterLab, primero debe crear una conexión entre el portátil Python que trabaja y el servicio de Consulta. Esto se puede lograr ejecutando la primera celda generada.
qs_connect()

En la segunda celda generada, la primera línea debe definirse antes de la consulta SQL. De forma predeterminada, la celda generada define una variable opcional ( df0 ) que guarda los resultados de la consulta como un dataframe de Pandas.
El -c QS_CONNECTION argumento es obligatorio e indica al núcleo que ejecute la consulta SQL contra el servicio de Consulta. Consulte el apéndice para ver 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 a las variables Python directamente dentro de una consulta SQL utilizando sintaxis con formato de cadena y ajustando las variables entre llaves ( {} ), como se muestra en el siguiente ejemplo:
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 en Python/R

Para acceder y filtrar un conjunto de datos de ExperienceEvent en un bloc de notas Python o 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 describe una lista de los operadores de filtrado:
  • eq() : Equal to
  • gt() : Greater than
  • ge() : Greater than or equal to
  • lt() : Less than
  • le() : Less than or equal to
  • And() :: Operador AND lógico
  • Or() :: Operador lógico OR
Las siguientes celdas filtran un conjunto de datos de ExperienceEvent a datos que existen exclusivamente entre el 1 de enero de 2019 y el 31 de diciembre de 2019.
# Python

client_context = PLATFORM_SDK_CLIENT_CONTEXT
from platform_sdk.dataset_reader import DatasetReader

dataset_reader = DatasetReader(client_context, "{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()

# R

library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
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(client_context, "{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()

Filtrar datos de ExperienceEvent en PySpark/Spark

El acceso y filtrado de un conjunto de datos de ExperienceEvent en un bloc de notas de PySpark o Scala requiere que proporcione la identidad del 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 una cadena de consulta SQL.
Las siguientes celdas filtran un conjunto de datos de ExperienceEvent a datos que existen exclusivamente entre el 1 de enero de 2019 y el 31 de diciembre de 2019.

PySpark 3 (Spark 2.4)

# PySpark 3 (Spark 2.4)

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

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

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()

Scala (Spark 2.4)

// 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()

En Scala, puede utilizar sys.env() para declarar y devolver un valor desde dentro option . Esto elimina la necesidad de definir variables si sabe que sólo se van a usar una sola vez. El siguiente ejemplo toma val userToken del ejemplo anterior y lo declara en línea dentro de option como alternativa:
.option("user-token", sys.env("PYDASDK_IMS_USER_TOKEN"))

Bibliotecas admitidas

Python / R

Biblioteca
Versión
portátil
6.0.0
solicitudes
2.22.0
tríptico
4.0.0
folium
0.10.0
ipywidgets
7.5.1
bokeh
1.3.1
gensim
3.7.3
ipyparalelo
0.5.2
jq
1.6
keras
2.2.4
nltk
3.2.5
pandas
0.22.0
pandasql
0.7.3
almohada
6.0.0
scikit-image
0.15.0
scikit-learn
0.21.3
scipy
1.3.0
scrapy
1.3.0
seaborn
0.9.0
modelos de estado
0.10.1
elástico
5.1.0.17
gráfico
0.11.5
py-xgboox
0.90
opencv
3.4.1
pyspark
2.4.3
pytorch
1.0.1
wxpython
4.0.6
colorlover
0.3.0
geopandas
0.5.1
pyshp
2.1.0
de forma
1.6.4
rpy2
2.9.4
r-essentials
3.6
r-arules
1.6_3
r-fpc
2.2_3
r-e1071
1.7_2
r-gam
1.16.1
r-gbm
2.1.5
r-temas
4.2.0
r-ggvis
0.4.4
r-igraph
1.2.4.1
r-saltos
3.0
volver a manipular
1.0.1
r-rocr
1.0_7
r-rmysql
0.10.17
r-rodbc
1.3_15
r-rsqlite
2.1.2
r-rstan
2.19.2
r-sqldf
0.4_11
r-supervivencia
2.44_1.1
r-zoo
1.8_6
r-stringdist
0.9.5.2
r-quadprog
1.5_7
r-rjson
0.2.20
r-previsión
8.7
r-resolnp
1.16
r-reticulate
1.12
r-mlr
2.14.0
r-viridis
0.5.1
r-corplot
0.84
r-fnn
1.1.3
r-lubridate
1.7.4
r-randomforest
4.6_14
r-tidyverse
1.2.1
r-tree
1.0_39
pymongo
3.8.0
pyarrow
0.14.1
boto3
1.9.199
ipyvolumen
0.5.2
fastparquet
0.3.2
python-sndish
0.5.4
ipywebrtc
0.5.0
jupyter_client
5.3.1
wordcloud
1.5.0
grafviz
2.40.1
python-graphviz
0.11.1
azure-almacenamiento
0.36.0
jupyterlab
1.0.4
pandas_ml
0.6.1
tensorflow-gpu
1.14.0
nodejs
12.3.0
mock
3.0.5
ipympl
0.3.3
fonts-anacond
1.0
psycopg2
2.8.3
nariz
1.3.7
autovizwidget
0.12.9
altair
3.1.0
vega_datasets
0.7.0
papermill
1.0.1
sql_Magic
0.0.4
iso3166
1.0
nbimporter
0.3.1

PySpark

Biblioteca
Versión
solicitudes
2.18.4
gensim
2.3.0
keras
2.0.6
nltk
3.2.4
pandas
0.20.1
pandasql
0.7.3
almohada
5.3.0
scikit-image
0.13.0
scikit-learn
0.19.0
scipy
0.19.1
scrapy
1.3.3
modelos de estado
0.8.0
elástico
4.0.30.44
py-xgboox
0.60
opencv
3.1.0
pyarrow
0.8.0
boto3
1.5.18
azure-almacenamiento-blob
1.4.0
python
3.6.7
mkl-rt
11.1

Indicadores SQL opcionales para el servicio de Consulta

Esta tabla describe los indicadores SQL opcionales que se pueden utilizar para el servicio de Consulta.
Indicador
Descripción
-h , --help
Muestre el mensaje de ayuda y salga.
-n , --notify
Alternar la opción para notificar los resultados de la consulta.
-a , --async
El uso de este indicador ejecuta la consulta asincrónicamente y puede liberar el núcleo mientras la consulta se está ejecutando. Tenga cuidado al asignar resultados de consulta a variables, ya que podría no estar definida si la consulta no se ha completado.
-d , --display
El uso de este indicador evita que se muestren los resultados.