Dataåtkomst i Jupyterlab anteckningsböcker

Varje kärna som stöds har inbyggda funktioner som gör att du kan läsa plattformsdata från en datamängd i en anteckningsbok. JupyterLab i Adobe Experience Platform Data Science Workspace stöder för närvarande bärbara datorer för Python, R, PySpark och Scala. Stöd för sidnumrering av data är dock begränsat till bärbara datorer från Python och R. Den här guiden fokuserar på hur du använder JupyterLab-anteckningsböcker för att få tillgång till dina data.

Komma igång

Innan du läser den här guiden bör du läsa JupyterLab användarhandboken för en introduktion på hög nivå till JupyterLab och dess roll inom Data Science Workspace.

Datagränser för bärbara datorer notebook-data-limits

Följande information definierar den maximala mängden data som kan läsas, vilken typ av data som användes och den beräknade tidsramen som läser data.

För Python och R användes en anteckningsboksserver som konfigurerats med 40 GB RAM för prestandatesterna. För PySpark och Scala användes ett databricks-kluster som konfigurerats med 64 GB RAM, 8 kärnor, 2 DBU med högst 4 arbetare för de riktmärken som beskrivs nedan.

De ExperienceEvent-schemadata som användes varierade i storlek från ett tusen (1 K) rader på upp till en miljard (1B) rader. Observera att för PySpark- och Spark-måtten användes ett datumintervall på 10 dagar för XDM-data.

Ad hoc-schemadata bearbetades i förväg med Query Service Skapa tabell som markerad (CTAS). Dessa data varierade också i storlek från ett tusen (1K) rader, upp till en miljard (1B) rader.

Använd batchläge jämfört med interaktivt läge mode

När du läser datauppsättningar med bärbara datorer från PySpark och Scala kan du välja att använda interaktivt läge eller gruppläge för att läsa datauppsättningen. Interaktiv används för snabba resultat, medan batchläge används för stora datauppsättningar.

Datagränser för Python bärbara datorer

XDM ExperienceEvent-schema: Du bör kunna läsa högst 2 miljoner rader (~6,1 GB data på disk) med XDM-data på mindre än 22 minuter. Om du lägger till ytterligare rader kan det leda till fel.

ad hoc-schema: Du bör kunna läsa upp maximalt 5 miljoner rader (~5,6 GB data på disk) med data som inte är XDM (ad hoc) på mindre än 14 minuter. Om du lägger till ytterligare rader kan det leda till fel.

Datagränser för bärbara datorer

XDM ExperienceEvent-schema: Du bör kunna läsa högst 1 miljon rader med XDM-data (3 GB-data på disk) på mindre än 13 minuter.

ad hoc-schema: Du bör kunna läsa upp maximalt 3 miljoner rader ad hoc-data (293 MB data på disk) på ca 10 minuter.

Datagränsgränser för PySpark (Python kernel)-anteckningsbok: pyspark-data-limits

XDM ExperienceEvent-schema: I interaktivt läge bör du kunna läsa högst 5 miljoner rader (~13,42 GB data på disk) med XDM-data på ca 20 minuter. Interaktivt läge stöder endast upp till 5 miljoner rader. Om du vill läsa större datauppsättningar rekommenderar vi att du växlar till gruppläge. I gruppläge bör du kunna läsa upp maximalt 500 miljoner rader (~1,31 TB data på disk) med XDM-data på ca 14 timmar.

ad hoc-schema: I interaktivt läge bör du kunna läsa högst 5 miljoner rader (~5,36 GB data på disk) med data som inte är XDM på mindre än 3 minuter. I gruppläge bör du kunna läsa upp maximalt 1 miljard rader (~1,05 TB data på disk) med data som inte är XDM på ca 18 minuter.

Datagränser för Spark (Skalkärna) i anteckningsboken: scala-data-limits

XDM ExperienceEvent-schema: I interaktivt läge bör du kunna läsa högst 5 miljoner rader (~13,42 GB data på disk) med XDM-data på ca 18 minuter. Interaktivt läge stöder endast upp till 5 miljoner rader. Om du vill läsa större datauppsättningar rekommenderar vi att du växlar till gruppläge. I gruppläge bör du kunna läsa upp maximalt 500 miljoner rader (~1,31 TB data på disk) med XDM-data på ca 14 timmar.

ad hoc-schema: I interaktivt läge bör du kunna läsa upp maximalt 5 miljoner rader (~5,36 GB data på disk) med data som inte är XDM på mindre än 3 minuter. I gruppläge bör du kunna läsa upp maximalt 1 miljard rader (~1,05 TB data på disk) med data som inte är XDM på ca 16 minuter.

Python bärbara datorer python-notebook

Med Python anteckningsböcker kan du numrera data när du använder datauppsättningar. Exempelkod för att läsa data med och utan sidnumrering visas nedan. Mer information om de tillgängliga startböckerna för Python finns i avsnittet JupyterLab Starta i användarhandboken för JupyterLab.

Python-dokumentationen nedan beskriver följande koncept:

Läs från en datauppsättning i Python python-read-dataset

Utan sidnumrering:

Om du kör följande kod läses hela datauppsättningen. Om körningen lyckas kommer data att sparas som en Pandas-dataram som refereras av variabeln 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()

Med sidnumrering:

Om du kör följande kod läses data från den angivna datauppsättningen. Sidnumrering uppnås genom att data begränsas och förskjuts via funktionerna limit() och offset(). Begränsande data avser det maximala antalet datapunkter som ska läsas, medan förskjutning avser antalet datapunkter som ska hoppas över före läsning av data. Om läsåtgärden körs kommer data att sparas som en Pandas-dataram som refereras av variabeln 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()

Skriv till en datauppsättning i Python write-python

Om du vill skriva till en datauppsättning i JupyterLab-anteckningsboken väljer du ikonfliken Data (markerad nedan) i den vänstra navigeringen i JupyterLab. Katalogerna Datasets och Schemas visas. Välj Datasets och högerklicka och välj sedan alternativet Write Data in Notebook i listrutan på den datauppsättning som du vill använda. En körbar kodpost visas längst ned i anteckningsboken.

Du kan också kopiera och klistra in följande kodcell. Ersätt både {DATASET_ID} och {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')

Fråga data med Query Service i Python query-data-python

Med JupyterLab på Platform kan du använda SQL i en Python anteckningsbok för att komma åt data via Adobe Experience Platform Query Service. Åtkomst av data via Query Service kan vara användbart för hantering av stora datamängder på grund av dess överlägsna körtider. Observera att en fråga om data som använder Query Service har en bearbetningstid på tio minuter.

Innan du använder Query Service i JupyterLab måste du ha en fungerande förståelse för Query Service SQL-syntaxen.

Om du frågar efter data med Query Service måste du ange namnet på måldatauppsättningen. Du kan generera de nödvändiga kodcellerna genom att hitta den önskade datauppsättningen med Data explorer. Högerklicka på datauppsättningslistan och klicka på Query Data in Notebook för att generera två kodceller i anteckningsboken. Dessa två celler beskrivs mer ingående nedan.

För att kunna använda Query Service i JupyterLab måste du först skapa en anslutning mellan din Python fungerande anteckningsbok och Query Service. Detta kan du göra genom att köra den första genererade cellen.

qs_connect()

I den andra genererade cellen måste den första raden definieras före SQL-frågan. Som standard definierar den genererade cellen en valfri variabel (df0) som sparar frågeresultatet som en Pandas-dataram.
Argumentet -c QS_CONNECTION är obligatoriskt och anger för kerneln att köra SQL-frågan mot Query Service. I bilagan finns en lista med ytterligare argument.

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

Python-variabler kan refereras direkt i en SQL-fråga med strängformaterad syntax och variabler inom klammerparenteser ({}), vilket visas i följande exempel:

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}

Filtrera ExperienceEvent-data python-filter

För att få åtkomst till och filtrera en ExperienceEvent-datauppsättning i en Python-anteckningsbok måste du ange datauppsättningens ID ({DATASET_ID}) tillsammans med filterreglerna som definierar ett specifikt tidsintervall med hjälp av logiska operatorer. När ett tidsintervall definieras, ignoreras alla angivna sidnumreringar och hela datauppsättningen beaktas.

En lista med filtreringsoperatorer beskrivs nedan:

Följande cell filtrerar en ExperienceEvent-datauppsättning till data som finns exklusivt mellan 1 januari 2019 och 31 december 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 bärbara datorer r-notebooks

Med R-anteckningsböcker kan du numrera data när du använder datauppsättningar. Exempelkod för att läsa data med och utan sidnumrering visas nedan. Mer information om vilka bärbara startböcker som är tillgängliga finns i avsnittet JupyterLab Startprogram i användarhandboken för JupyterLab.

I R-dokumentationen nedan beskrivs följande begrepp:

Läs från en datauppsättning i R r-read-dataset

Utan sidnumrering:

Om du kör följande kod läses hela datauppsättningen. Om körningen lyckas kommer data att sparas som en Pandas-dataram som refereras av variabeln 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)

Med sidnumrering:

Om du kör följande kod läses data från den angivna datauppsättningen. Sidnumrering uppnås genom att data begränsas och förskjuts via funktionerna limit() och offset(). Begränsande data avser det maximala antalet datapunkter som ska läsas, medan förskjutning avser antalet datapunkter som ska hoppas över före läsning av data. Om läsåtgärden körs kommer data att sparas som en Pandas-dataram som refereras av variabeln 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()

Skriv till en datauppsättning i R write-r

Om du vill skriva till en datauppsättning i JupyterLab-anteckningsboken väljer du ikonfliken Data (markerad nedan) i den vänstra navigeringen i JupyterLab. Katalogerna Datasets och Schemas visas. Välj Datasets och högerklicka och välj sedan alternativet Write Data in Notebook i listrutan på den datauppsättning som du vill använda. En körbar kodpost visas längst ned i anteckningsboken.

Du kan också kopiera och klistra in följande kodcell:

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

Filtrera ExperienceEvent-data r-filter

För att få åtkomst till och filtrera en ExperienceEvent-datauppsättning i en R-anteckningsbok måste du ange datauppsättningens ID ({DATASET_ID}) tillsammans med filterreglerna som definierar ett specifikt tidsintervall med logiska operatorer. När ett tidsintervall definieras, ignoreras alla angivna sidnumreringar och hela datauppsättningen beaktas.

En lista med filtreringsoperatorer beskrivs nedan:

Följande cell filtrerar en ExperienceEvent-datauppsättning till data som finns exklusivt mellan 1 januari 2019 och 31 december 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 bärbara datorer pyspark-notebook

I PySpark-dokumentationen nedan beskrivs följande begrepp:

Initierar sparkSession spark-initialize

Alla Spark 2.4-anteckningsböcker kräver att du initierar sessionen med följande standardkod.

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

Använda %dataset för att läsa och skriva med en PySpark 3-anteckningsbok magic

I och med introduktionen av Spark 2.4 tillhandahålls %dataset anpassad magi för användning i bärbara datorer med PySpark 3 (Spark 2.4). Mer information om magiska kommandon som är tillgängliga i IPython-kärnan finns i dokumentationen för IPython-magin.

Användning

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

Beskrivning

Ett anpassat magiskt Data Science Workspace-kommando för att läsa eller skriva en datauppsättning från en PySpark-anteckningsbok (Python 3-kärna).

Exempel

Du kan generera exemplen ovan automatiskt i JupyterLab-köp med följande metod:

Välj fliken Data icon (markerad nedan) i den vänstra navigeringen i JupyterLab. Katalogerna Datasets och Schemas visas. Välj Datasets och högerklicka och välj sedan alternativet Write Data in Notebook i listrutan på den datauppsättning som du vill använda. En körbar kodpost visas längst ned i anteckningsboken.

Skapa en lokal dataram pyspark-create-dataframe

Om du vill skapa en lokal dataram med PySpark 3 använder du SQL-frågor. Exempel:

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)

Filtrera ExperienceEvent-data pyspark-filter-experienceevent

Om du vill komma åt och filtrera en ExperienceEvent-datauppsättning i en PySpark-anteckningsbok måste du ange datamängdsidentiteten ({DATASET_ID}), organisationens IMS-identitet och filterreglerna som definierar ett visst tidsintervall. Ett filtertidsintervall definieras med funktionen spark.sql(), där funktionsparametern är en SQL-frågesträng.

Följande celler filtrerar en ExperienceEvent-datauppsättning till data som finns exklusivt mellan 1 januari 2019 och 31 december 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()

Skala bärbara datorer scala-notebook

Dokumentationen nedan innehåller exempel på följande koncept:

Initierar SparkSession scala-initialize

Alla Scala-anteckningsböcker kräver att du initierar sessionen med följande standardkod:

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

Läs en datauppsättning read-scala-dataset

I Scala kan du importera clientContext för att hämta och returnera plattformsvärden, vilket eliminerar behovet av att definiera variabler som var userToken. I exemplet Scala nedan används clientContext för att hämta och returnera alla värden som krävs för att läsa en datauppsättning.

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)

Du kan generera exemplet ovan automatiskt i JupyterLab genom att använda följande metod:

Välj fliken Data icon (markerad nedan) i den vänstra navigeringen i JupyterLab. Katalogerna Datasets och Schemas visas. Välj Datasets och högerklicka och välj sedan alternativet Explore Data in Notebook i listrutan på den datauppsättning som du vill använda. En körbar kodpost visas längst ned i anteckningsboken.
Och

Skriv till en datauppsättning scala-write-dataset

I Scala kan du importera clientContext för att hämta och returnera plattformsvärden, vilket eliminerar behovet av att definiera variabler som var userToken. I exemplet Scala nedan används clientContext för att definiera och returnera alla värden som krävs för att skriva till en datauppsättning.

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

skapa en lokal dataram scala-create-dataframe

SQL-frågor krävs för att skapa en lokal dataram med Scala. Exempel:

sparkdf.createOrReplaceTempView("sparkdf")

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

Filtrera ExperienceEvent-data scala-experienceevent

Om du vill komma åt och filtrera en ExperienceEvent-datauppsättning i en Scala-anteckningsbok måste du ange datamängdens identitet ({DATASET_ID}), organisationens IMS-identitet och filterreglerna som definierar ett visst tidsintervall. Ett filtertidsintervall definieras med funktionen spark.sql(), där funktionsparametern är en SQL-frågesträng.

Följande celler filtrerar en ExperienceEvent-datauppsättning till data som finns exklusivt mellan 1 januari 2019 och 31 december 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ästa steg

Det här dokumentet innehåller allmänna riktlinjer för åtkomst av datauppsättningar med JupyterLab-anteckningsböcker. Mer information om hur du frågar efter datauppsättningar finns i frågetjänsten i dokumentationen för JupyterLab-anteckningsböcker. Mer information om hur du utforskar och visualiserar dina datauppsättningar finns i dokumentet om att analysera dina data med hjälp av anteckningsböcker.

Valfria SQL-flaggor för Query Service optional-sql-flags-for-query-service

Den här tabellen visar de valfria SQL-flaggor som kan användas för Query Service.