Datenzugriff in Jupyterlab Notebooks

Jeder unterstützte Kernel bietet native Funktionen, mit denen Sie Platform-Daten aus einem Datensatz in einem Notebook lesen können. Derzeit unterstützt JupyterLab in Adobe Experience Platform Data Science Workspace Notebooks für Python, R, PySpark und Scala. However, support for paginating data is limited to Python and R notebooks. Dieser Leitfaden konzentriert sich darauf, wie Sie mit JupyterLab-Notebooks auf Ihre Daten zugreifen können.

Erste Schritte

Bevor Sie dieses Handbuch lesen, lesen Sie sich bitte das JupyterLab Benutzerhandbuch für eine allgemeine Einführung in JupyterLab und seine Rolle innerhalb des Data Science Workspace durch.

Einschränkungen bei Notebook-Daten

WICHTIG

Bei PySpark- und Scala-Notebooks, wenn Sie einen Fehler mit dem Grund "Remote RPC-Client getrennt" erhalten. Dies bedeutet in der Regel, dass dem Treiber oder einem Assistenten der Arbeitsspeicher ausgeht. Versuchen Sie, diesen Fehler zu beheben, indem Sie in den "Batch"-Modus wechseln.

Die folgenden Informationen definieren die maximale Datenmenge, die gelesen werden kann, welche Art von Daten verwendet wurde und den geschätzten Zeitrahmen, in dem die Daten gelesen werden.

Für Python und R wurde ein mit 40 GB RAM konfigurierter Notebook-Server für die Benchmarks verwendet. Für PySpark und Scala wurde ein mit 64 GB RAM, 8 Kerne, 2 DBU mit maximal 4 Mitarbeitern konfigurierter Datenbankcluster für die unten beschriebenen Benchmarks verwendet.

Die verwendeten ExperienceEvent-Schema-Daten variierten in der Größe von 1.000 Zeilen bis zu einer Milliarde Zeilen (1B). Beachten Sie, dass für die PySpark- und Spark Metriken ein Datumsbereich von 10 Tagen für die XDM-Daten verwendet wurde.

Die Ad-hoc-Schema-Daten wurden vorab mit Query Service Tabelle als Auswahl erstellen (CTAS) verarbeitet. Diese Daten variierten auch in der Größe von 1.000 Zeilen (1.000) bis zu einer Milliarde (1.000) Zeilen.

Verwendung des Stapelmodus im interaktiven Modus

Beim Lesen von Datensätzen mit PySpark- und Scala-Notebooks haben Sie die Möglichkeit, den Datensatz im interaktiven Modus oder im Stapelmodus zu lesen. Interaktiv erfolgt die Erstellung schneller Ergebnisse, während der Stapelmodus für große Datensätze gilt.

  • Bei PySpark- und Scala-Notebooks sollte der Stapelmodus verwendet werden, wenn mindestens 5 Millionen Datenzeilen gelesen werden. Weitere Informationen zur Effizienz der einzelnen Modi finden Sie in den Tabellen PySpark und Scala .

Python Datenbeschränkungen für Notebooks

XDM ExperienceEvent-Schema: Sie sollten maximal 2 Millionen Zeilen (~6,1 GB Daten auf der Festplatte) XDM Daten in weniger als 22 Minuten lesen können. Das Hinzufügen zusätzlicher Zeilen kann zu Fehlern führen.

Anzahl Zeilen 1K 10K 100K 1M 2M
Größe auf Festplatte (MB) 18.73 187.5 308 3000 6050
SDK (in Sekunden) 20.3 86.8 63 659 1315

Ad-hoc-Schema: Sie sollten maximal 5 Millionen Zeilen (~5,6 GB Daten auf der Festplatte) von Nicht-XDM-Daten (Ad-hoc-Daten) in weniger als 14 Minuten lesen können. Das Hinzufügen zusätzlicher Zeilen kann zu Fehlern führen.

Anzahl Zeilen 1K 10K 100K 1M 2M 3M 5M
Größe auf Festplatte (in MB) 1.21 11.72 115 1120 2250 3380 5630
SDK (in Sekunden) 7.27 9.04 27.3 180 346 487 819

R Datenbeschränkungen für Notebooks

XDM ExperienceEvent-Schema: Sie sollten in weniger als 13 Minuten maximal 1 Million Zeilen XDM Daten (3 GB Daten auf Festplatte) lesen können.

Anzahl Zeilen 1K 10K 100K 1M
Größe auf Festplatte (MB) 18.73 187.5 308 3000
R Kernel (in Sekunden) 14.03 69.6 86.8 775

Ad-hoc-Schema: Sie sollten in etwa 10 Minuten maximal 3 Millionen Zeilen Ad-hoc-Daten (293 MB Daten auf dem Datenträger) lesen können.

Anzahl Zeilen 1K 10K 100K 1M 2M 3M
Größe auf Festplatte (in MB) 0.082 0.612 9.0 91 188 293
R SDK (in Sekunden) 7.7 4.58 35.9 233 470.5 603

Datenbeschränkungen für PySpark-Notebooks (Python Kernel):

XDM ExperienceEvent-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~13,42 GB Daten auf Festplatte) XDM Daten in etwa 20 Minuten lesen können. Der interaktive Modus unterstützt nur bis zu 5 Millionen Zeilen. Wenn Sie größere Datensätze lesen möchten, sollten Sie zum Stapelmodus wechseln. Im Batch-Modus sollten Sie maximal 500 Millionen Zeilen (~1,31 TB Daten auf der Festplatte) XDM Daten in etwa 14 Stunden lesen können.

Anzahl Zeilen 1K 10K 100K 1M 2M 3M 5M 10M 50M 100M 500M
Größe auf dem Datenträger 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 (interaktiver Modus) 33 Sek. 32.4 Sek. 55.1 Sek. 253.5 Sek. 489.2 Sek. 729.6 Sek. 1206.8 Sek.
SDK (Stapelmodus) 815.8 Sek. 492.8 Sek. 379.1 Sek. 637.4 Sek. 624.5 Sek. 869.2 Sek. 1104.1 Sek. 1786 Sek. 5387.2 Sek. 10624.6 Sek. 50547 Sek.

Ad-hoc-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~5,36 GB Daten auf der Festplatte) ohne XDM Daten in weniger als 3 Minuten lesen können. Im Batch-Modus sollten Sie maximal 1 Milliarde Zeilen (~1.05TB Daten auf Festplatte) von Nicht-XDM Daten in etwa 18 Minuten lesen können.

Anzahl Zeilen 1K 10K 100K 1M 2M 3M 5M 10M 50M 100M 500M 1B
Größe auf Datenträger 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
SDK-Interaktiver Modus (in Sekunden) 28.2 Sek. 18.6 Sek. 20.8 Sek. 20.9 Sek. 23.8 Sek. 21.7 Sek. 24.7 Sek.
SDK-Stapelmodus (in Sekunden) 428.8 Sek. 578.8 Sek. 641.4 Sek. 538.5 Sek. 630.9 Sek. 467.3 Sek. 411 Sek. 675 Sek. 702 Sek. 719.2 Sek. 1022.1 Sek. 1122.3 Sek.

Spark (Scala-Kernel) Datenbeschränkungen für Notebooks:

XDM ExperienceEvent-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~13,42 GB Daten auf Festplatte) XDM Daten in etwa 18 Minuten lesen können. Der interaktive Modus unterstützt nur bis zu 5 Millionen Zeilen. Wenn Sie größere Datensätze lesen möchten, sollten Sie zum Stapelmodus wechseln. Im Batch-Modus sollten Sie maximal 500 Millionen Zeilen (~1,31 TB Daten auf der Festplatte) XDM Daten in etwa 14 Stunden lesen können.

Anzahl Zeilen 1K 10K 100K 1M 2M 3M 5M 10M 50M 100M 500M
Größe auf Datenträger 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-Interaktiver Modus (in Sekunden) 37.9 Sek. 22.7 Sek. 45.6 Sek. 231.7 Sek. 444.7 Sek. 660.6 Sek. 1100 Sek.
SDK-Stapelmodus (in Sekunden) 374.4 Sek. 398.5 Sek. 527 Sek. 487.9 Sek. 588.9 Sek. 829 Sek. 939.1 Sek. 1441 Sek. 5473.2 Sek. 10118.8 49207.6

Ad-hoc-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~5,36 GB Daten auf der Festplatte) ohne XDM Daten in weniger als 3 Minuten lesen können. Im Batch-Modus sollten Sie maximal 1 Milliarde Zeilen (~1,05 TB Daten auf Festplatte) von Nicht-XDM Daten in etwa 16 Minuten lesen können.

Anzahl Zeilen 1K 10K 100K 1M 2M 3M 5M 10M 50M 100M 500M 1B
Größe auf Datenträger 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
SDK-Interaktiver Modus (in Sekunden) 35.7 Sek. 31 Sek. 19.5 Sek. 25.3 Sek. 23 Sek. 33.2 Sek. 25.5 Sek.
SDK-Stapelmodus (in Sekunden) 448.8 Sek. 459.7 Sek. 519 Sek. 475.8 Sek. 599.9 Sek. 347.6 Sek. 407.8 Sek. 397 Sek. 518.8 Sek. 487.9 Sek. 760.2 Sek. 975.4 Sek.

Python-Notebooks

Python Mit Notebooks können Sie Daten beim Zugriff auf Datensätze paginieren. Nachstehend finden Sie Beispiel-Code zum Lesen von Daten mit und ohne Paginierung. Weitere Informationen zu den verfügbaren Starter-Python-Notebooks finden Sie im JupyterLab Starter -Abschnitt des JupyterLab-Benutzerhandbuchs.

Die nachstehende Python-Dokumentation beschreibt die folgenden Konzepte:

Read from a dataset in Python

Ohne Paginierung:

Wenn Sie den folgenden Code ausführen, wird der gesamte Datensatz gelesen. Bei erfolgreicher Ausführung werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df verweist.

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

Mit Paginierung:

Wenn Sie folgenden Code ausführen, werden Daten aus dem angegebenen Datensatz gelesen. Paginierung wird erreicht, indem Daten über die Funktion limit() bzw. offset() begrenzt und versetzt werden. Datenbegrenzung bezieht sich auf die maximale Anzahl der zu lesenden Datenpunkte, während Versatz auf die Anzahl der Datenpunkte verweist, die vor dem Lesen von Daten übersprungen werden. Wenn der Lesevorgang erfolgreich ausgeführt wird, werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df verweist.

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

Schreiben in einen Datensatz in Python

Um in ein Dataset in Ihrem JupyterLab-Notebook zu schreiben, wählen Sie in der linken Navigation von JupyterLab die Registerkarte "Datensymbol"(unten hervorgehoben). Die Ordner Datasets und Schemas werden angezeigt. Wählen Sie Datensätze aus und klicken Sie mit der rechten Maustaste und wählen Sie dann im Dropdown-Menü des zu verwendenden Datensatzes die Option Daten in Notebook ​schreiben. Am unteren Rand des Notebooks wird ein ausführbarer Code-Eintrag angezeigt.

  • Verwenden Sie Daten in Notebook schreiben, um eine Schreibzelle mit dem ausgewählten Datensatz zu erstellen.
  • Verwenden Sie Daten im Notebook durchsuchen, um eine Lesezelle mit dem ausgewählten Datensatz zu erstellen.
  • Verwenden Sie die Abfragen-Daten im Notebook , um eine Basiszelle für die Abfrage mit Ihrem ausgewählten Datensatz zu erstellen.

Alternativ können Sie die folgende Codezelle kopieren und einfügen. Ersetzen Sie sowohl die {DATASET_ID} als auch {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')

Abfragen mit Query Service in Python

JupyterLab auf Platform ermöglicht Ihnen die Verwendung von SQL in einem Python Notebook, um über den Adobe Experience Platform Abfrage Serviceauf Daten zuzugreifen. Accessing data through Query Service can be useful for dealing with large datasets due to its superior running times. Be advised that querying data using Query Service has a processing time limit of ten minutes.

Before you use Query Service in JupyterLab, ensure you have a working understanding of the Query Service SQL syntax.

Querying data using Query Service requires you to provide the name of the target dataset. Sie können die erforderlichen Code-Zellen generieren, indem Sie den gewünschten Datensatz mit dem Data Explorer suchen. Right click on the dataset listing and click Query Data in Notebook to generate two code cells in your notebook. Diese beiden Zellen werden nachstehend detaillierter beschrieben.

In order to utilize Query Service in JupyterLab, you must first create a connection between your working Python notebook and Query Service. Dies kann durch Ausführen der ersten generierten Zelle erreicht werden.

qs_connect()

In der zweiten generierten Zelle muss die erste Zeile vor der SQL-Abfrage definiert werden. Standardmäßig definiert die generierte Zelle eine optionale Variable (df0), mit der die Abfrageergebnisse als Pandas-Dataframe gespeichert werden.
Das -c QS_CONNECTION Argument ist obligatorisch und weist den Kernel an, die SQL-Abfrage gegen auszuführen Query Service. Eine Liste weiterer Argumente finden Sie im Anhang.

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

Python-Variablen können in einer SQL-Abfrage direkt referenziert werden, indem Sie eine im Zeichenfolgenformat formatierte Syntax verwenden und die Variablen in geschweifte Klammern ({}) setzen (siehe folgendes Beispiel):

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}

Filter ExperienceEvent data

In order to access and filter an ExperienceEvent dataset in a Python notebook, you must provide the ID of the dataset ({DATASET_ID}) along with the filter rules that define a specific time range using logical operators. Wenn ein Zeitraum definiert ist, wird jede angegebene Paginierung ignoriert und der gesamte Datensatz berücksichtigt.

Eine Liste der Filteroperatoren finden Sie nachfolgend:

  • eq(): Gleich
  • gt(): Größer als
  • ge(): Größer oder gleich
  • lt(): Niedriger als
  • le(): Kleiner oder gleich
  • And(): Logischer UND-Operator
  • Or(): Logischer ODER-Operator

The following cell filters an ExperienceEvent dataset to data existing exclusively between January 1, 2019 and the end of December 31, 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()

R Notebooks

Mit R-Notebooks können Sie Daten beim Zugriff auf Datensätze paginieren. Nachstehend finden Sie Beispiel-Code zum Lesen von Daten mit und ohne Paginierung. Weitere Informationen zu den verfügbaren Start-R-Notebooks finden Sie im JupyterLab-Benutzerhandbuch im Abschnitt JupyterLab Starter .

Die nachstehende R-Dokumentation enthält folgende Konzepte:

Read from a dataset in R

Ohne Paginierung:

Wenn Sie den folgenden Code ausführen, wird der gesamte Datensatz gelesen. Bei erfolgreicher Ausführung werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df0 verweist.

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

Mit Paginierung:

Wenn Sie folgenden Code ausführen, werden Daten aus dem angegebenen Datensatz gelesen. Paginierung wird erreicht, indem Daten über die Funktion limit() bzw. offset() begrenzt und versetzt werden. Datenbegrenzung bezieht sich auf die maximale Anzahl der zu lesenden Datenpunkte, während Versatz auf die Anzahl der Datenpunkte verweist, die vor dem Lesen von Daten übersprungen werden. Wenn der Lesevorgang erfolgreich ausgeführt wird, werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df0 verweist.

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

Schreiben in einen Datensatz in R

Um in ein Dataset in Ihrem JupyterLab-Notebook zu schreiben, wählen Sie in der linken Navigation von JupyterLab die Registerkarte "Datensymbol"(unten hervorgehoben). Die Ordner Datasets und Schemas werden angezeigt. Wählen Sie Datensätze aus und klicken Sie mit der rechten Maustaste und wählen Sie dann im Dropdown-Menü des zu verwendenden Datensatzes die Option Daten in Notebook ​schreiben. Am unteren Rand des Notebooks wird ein ausführbarer Code-Eintrag angezeigt.

  • Verwenden Sie Daten in Notebook schreiben, um eine Schreibzelle mit dem ausgewählten Datensatz zu erstellen.
  • Verwenden Sie Daten im Notebook durchsuchen, um eine Lesezelle mit dem ausgewählten Datensatz zu erstellen.

Alternativ können Sie die folgende Codezelle kopieren und einfügen:

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

Filter ExperienceEvent data

In order to access and filter an ExperienceEvent dataset in a R notebook, you must provide the ID of the dataset ({DATASET_ID}) along with the filter rules that define a specific time range using logical operators. Wenn ein Zeitraum definiert ist, wird jede angegebene Paginierung ignoriert und der gesamte Datensatz berücksichtigt.

Eine Liste der Filteroperatoren finden Sie nachfolgend:

  • eq(): Gleich
  • gt(): Größer als
  • ge(): Größer oder gleich
  • lt(): Niedriger als
  • le(): Kleiner oder gleich
  • And(): Logischer UND-Operator
  • Or(): Logischer ODER-Operator

The following cell filters an ExperienceEvent dataset to data existing exclusively between January 1, 2019 and the end of December 31, 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()

PySpark 3 Notebooks

Die nachstehende PySpark-Dokumentation enthält folgende Konzepte:

Initialisieren von sparkSession

Für alle Spark 2.4-Notebooks ist es erforderlich, dass Sie die Sitzung mit dem folgenden Textbausteincode initialisieren.

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

Verwenden von %dataset zum Lesen und Schreiben mit einem PySpark 3-Notebook

Mit der Einführung von Spark 2.4 wird %dataset die benutzerdefinierte Magie für die Verwendung in PySpark 3 (Spark 2.4) Notebooks geliefert. Weitere Informationen zu magischen Befehlen im IPython Kernel finden Sie in der IPython Magic Dokumentation.

Nutzung

%dataset {action} --datasetId {id} --dataFrame {df}`

Beschreibung

Ein benutzerdefinierter Data Science Workspace magischer Befehl zum Lesen oder Schreiben eines Datasets aus einem PySpark Notebook (Python 3 Kernel).

Name Beschreibung Erforderlich
{action} Der Aktionstyp, der für den Datensatz ausgeführt werden soll. Es stehen zwei Aktionen zur Verfügung: "Lesen"oder "Schreiben". Ja
--datasetId {id} Dient zum Ausgeben der ID des Datensatzes zum Lesen oder Schreiben. Ja
--dataFrame {df} Das Pandas-Datenblatt.
  • Wenn die Aktion "gelesen"ist, ist {df} die Variable, in der Ergebnisse des Datensatzlesevorgangs verfügbar sind.
  • Wenn die Aktion "schreiben"lautet, wird dieser Datenraum {df} in den Datensatz geschrieben.
Ja
--mode Ein zusätzlicher Parameter, der das Lesen von Daten ändert. Zulässige Parameter sind "batch"und "interaktiv". Standardmäßig ist der Modus auf "interaktiv"eingestellt. Es wird empfohlen, beim Lesen großer Datenmengen den Stapelmodus zu verwenden. Nein
TIPP

Überprüfen Sie die PySpark-Tabellen im Abschnitt mit den Datenbeschränkungen für Notebooks, um festzustellen, ob mode auf interactive oder batchfestgelegt werden sollte.

Beispiele

  • Beispiel lesen: %dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0
  • Beispiel schreiben: %dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0

Sie können die oben genannten Beispiele in JupyterLab Buy mit der folgenden Methode automatisch generieren:

Wählen Sie in der linken Navigation von JupyterLab die Registerkarte "Datensymbol"(unten hervorgehoben). Die Ordner Datasets und Schemas werden angezeigt. Wählen Sie Datensätze aus und klicken Sie mit der rechten Maustaste und wählen Sie dann im Dropdown-Menü des zu verwendenden Datensatzes die Option Daten in Notebook ​schreiben. Am unteren Rand des Notebooks wird ein ausführbarer Code-Eintrag angezeigt.

  • Verwenden Sie Daten im Notebook durchsuchen, um eine Lese-Zelle zu generieren.
  • Verwenden Sie Daten in Notebook schreiben, um eine Schreibzelle zu erstellen.

Lokales Datenwörterbuch erstellen

Verwenden Sie SQL-Abfragen, um mit PySpark 3 ein lokales Datenformat zu erstellen. Beispiel:

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

Sie können auch ein optionales Seed-Beispiel angeben, z. B. einen booleschen withReplacement, einen Dublette-Anteil oder einen langen Samen.

Filter ExperienceEvent data

Accessing and filtering an ExperienceEvent dataset in a PySpark notebook requires you to provide the dataset identity ({DATASET_ID}), your organization's IMS identity, and the filter rules defining a specific time range. A filtering time range is defined by using the function spark.sql(), where the function parameter is a SQL query string.

The following cells filter an ExperienceEvent dataset to data existing exclusively between January 1, 2019 and the end of December 31, 2019.

# 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-Notebooks

Die nachstehende Dokumentation enthält Beispiele für die folgenden Konzepte:

Initialisieren von SparkSession

Für alle Scala-Notebooks ist es erforderlich, dass Sie die Sitzung mit dem folgenden Textbausteincode initialisieren:

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

Datensatz lesen

In Scala können Sie clientContext zum Abrufen und Zurückgeben von Plattformwerten importieren, sodass Variablen wie var userTokenz. B. nicht definiert werden müssen. Im unten stehenden Scala-Beispiel clientContext werden alle erforderlichen Werte abgerufen und zurückgegeben, um einen Datensatz zu lesen.

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", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .load()

df1.printSchema()
df1.show(10)
Element Beschreibung
df1 Eine Variable, die den Pandas-Dataframe darstellt, mit dem Daten gelesen und geschrieben werden.
user-token Ihr Benutzertoken, das automatisch mit clientContext.getUserToken()abgerufen wird.
service-token Ihr Service-Token, das automatisch mit clientContext.getServiceToken()abgerufen wird.
ims-org Ihre IMS-Organisations-ID, die automatisch mit clientContext.getOrgId()abgerufen wird.
api-key Ihr API-Schlüssel, der automatisch mit clientContext.getApiKey()abgerufen wird.
TIPP

Überprüfen Sie die Scala-Tabellen im Abschnitt mit den Notebook-Datenbeschränkungen , um festzustellen, ob sie auf mode oder interactive batchfestgelegt werden sollten.

Sie können das obige Beispiel automatisch mit der folgenden Methode im JupyterLab-Kauf generieren:

Wählen Sie in der linken Navigation von JupyterLab die Registerkarte "Datensymbol"(unten hervorgehoben). Die Ordner Datasets und Schemas werden angezeigt. Wählen Sie " Datensätze "und klicken Sie mit der rechten Maustaste und wählen Sie dann im Dropdown-Menü des zu verwendenden Datensatzes die Option "Daten im Notebook ​untersuchen". Am unteren Rand des Notebooks wird ein ausführbarer Code-Eintrag angezeigt.
Und

  • Verwenden Sie Daten im Notebook durchsuchen, um eine Lese-Zelle zu generieren.
  • Verwenden Sie Daten in Notebook schreiben, um eine Schreibzelle zu erstellen.

In einen Datensatz schreiben

In Scala können Sie clientContext zum Abrufen und Zurückgeben von Plattformwerten importieren, sodass Variablen wie var userTokenz. B. nicht definiert werden müssen. Im unten stehenden Beispiel zur Skala clientContext werden alle erforderlichen Werte definiert und an einen Datensatz zurückgegeben.

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", "interactive")
  .option("dataset-id", "5e68141134492718af974844")
  .save()
element Beschreibung
df1 Eine Variable, die den Pandas-Dataframe darstellt, mit dem Daten gelesen und geschrieben werden.
user-token Ihr Benutzertoken, das automatisch mit clientContext.getUserToken()abgerufen wird.
service-token Ihr Service-Token, das automatisch mit clientContext.getServiceToken()abgerufen wird.
ims-org Ihre IMS-Organisations-ID, die automatisch mit clientContext.getOrgId()abgerufen wird.
api-key Ihr API-Schlüssel, der automatisch mit clientContext.getApiKey()abgerufen wird.
TIPP

Überprüfen Sie die Scala-Tabellen im Abschnitt mit den Notebook-Datenbeschränkungen , um festzustellen, ob sie auf mode oder interactive batchfestgelegt werden sollten.

ein lokales Dataframe erstellen

Zum Erstellen eines lokalen Datenspeichers mit Scala sind SQL-Abfragen erforderlich. Beispiel:

sparkdf.createOrReplaceTempView("sparkdf")

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

Filter ExperienceEvent data

Accessing and filtering an ExperienceEvent dataset in a Scala notebook requires you to provide the dataset identity ({DATASET_ID}), your organization's IMS identity, and the filter rules defining a specific time range. Ein Filterzeitbereich wird mithilfe der Funktion spark.sql() definiert, wobei der Funktionsparameter eine SQL-Abfragezeichenfolge ist.

The following cells filter an ExperienceEvent dataset to data existing exclusively between January 1, 2019 and the end of December 31, 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()

Nächste Schritte

Dieses Dokument enthielt die allgemeinen Richtlinien für den Zugriff auf Datensätze mit JupyterLab-Notebooks. Ausführlichere Beispiele zur Abfrage von Datensätzen finden Sie in der Dokumentation zum Abfrage-Dienst in JupyterLab-Notebooks . Weitere Informationen zur Erforschung und Visualisierung Ihrer Datensätze finden Sie im Dokument zur Analyse Ihrer Daten mithilfe von Notebooks.

Optional SQL flags for Query Service

This table outlines the optional SQL flags that can be used for Query Service.

Markierung Beschreibung
-h, --help Hilfemeldung anzeigen und beenden.
-n, --notify Umschaltoption für das Benachrichtigen bei Abfrageergebnissen.
-a, --async Bei Verwendung dieser Markierung wird die Abfrage asynchron ausgeführt und kann der Kernel freigeben werden, während die Abfrage ausgeführt wird. Seien Sie vorsichtig, wenn Sie Abfrageergebnisse Variablen zuweisen, da sie möglicherweise undefiniert sind, wenn die Abfrage noch nicht abgeschlossen ist.
-d, --display Die Verwendung dieser Markierung verhindert, dass Ergebnisse angezeigt werden.

Auf dieser Seite