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 Python och R bärbara datorer. 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 ska du läsa JupyterLab användarhandbok 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, en bärbar datorserver som konfigurerats med 40 GB RAM användes 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ätvärden, ett datumintervall på 10 dagar användes 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.

Python begränsningar för bärbara datordata

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 upp maximalt 1 miljon rader 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.

PySpark (Python kärna) datagränser för bärbara datorer: pyspark-data-limits

XDM ExperienceEvent-schema: I interaktivt läge bör du kunna läsa upp maximalt 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 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 18 minuter.

Spark Datagränser för bärbara datorer (Scala kernel): scala-data-limits

XDM ExperienceEvent-schema: I interaktivt läge bör du kunna läsa upp maximalt 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

Python Med bärbara datorer 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 på JupyterLab Startprogram 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 sparas data 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. Sidnumreringen uppnås genom att data begränsas och förskjuts genom funktionerna limit() och offset() respektive. 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 lyckas sparas data 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. The Datasets och Schemas -kataloger visas. Välj Datasets och högerklicka och välj sedan 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åda {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 in Python query-data-python

JupyterLab på Platform gör att du kan använda SQL i en Python bärbar dator 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 skicka frågor via Query Service har en bearbetningstid på tio minuter.

Innan du använder Query Service in JupyterLab, se till att du har en fungerande förståelse för Query Service SQL-syntax.

Frågar data med Query Service kräver att du anger namnet på måldatauppsättningen. Du kan generera nödvändiga kodceller genom att hitta den önskade datauppsättningen med hjälp av 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 utnyttja Query Service in JupyterLabmåste du först skapa en anslutning mellan ditt arbete Python 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ågeresultaten som en Pandas-dataram.
The -c QS_CONNECTION -argumentet är obligatoriskt och anger att kernel ska köra SQL-frågan mot Query Service. Se appendix om du vill visa 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 ({}), som 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}

Filter ExperienceEvent data python-filter

För att få tillgång till och filtrera en ExperienceEvent datauppsättning i en Python måste du ange datamängdens 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 och ExperienceEvent datauppsättning för 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 tillgängliga bärbara startböcker för R finns på 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 sparas data 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. Sidnumreringen uppnås genom att data begränsas och förskjuts genom funktionerna limit() och offset() respektive. 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 lyckas sparas data 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. The Datasets och Schemas -kataloger visas. Välj Datasets och högerklicka och välj sedan 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')

Filter ExperienceEvent data r-filter

För att få tillgång till och filtrera en ExperienceEvent datauppsättning i en R-anteckningsbok, du måste 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 och ExperienceEvent datauppsättning för 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 bärbara datorer 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

Med introduktionen av Spark 2.4, %dataset anpassad magi tillhandahålls för användning i PySpark 3 (Spark 2.4) bärbara datorer. Mer information om de magiska kommandona som finns i IPython-kärnan finns på Magisk dokumentation för IPython.

Användning

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

Beskrivning

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

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. The Datasets och Schemas -kataloger visas. Välj Datasets och högerklicka och välj sedan 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)

Filter ExperienceEvent data pyspark-filter-experienceevent

Åtkomst och filtrering av ett ExperienceEvent datauppsättningen i en PySpark-anteckningsbok kräver att du anger 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 ett ExperienceEvent datauppsättning för 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 elimineras behovet av att definiera variabler som var userToken. I Scala-exemplet nedan clientContext används för att hämta och returnera alla värden som behö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. The Datasets och Schemas -kataloger visas. Välj Datasets och högerklicka och välj sedan 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 elimineras behovet av att definiera variabler som var userToken. I Scala-exemplet nedan clientContext används för att definiera och returnera alla värden som behö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)

Filter ExperienceEvent data scala-experienceevent

Åtkomst och filtrering av ett ExperienceEvent datauppsättningen i en Scala-anteckningsbok kräver att du anger datauppsättningens 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 ett ExperienceEvent datauppsättning för 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 ställer frågor om datauppsättningar finns på Frågetjänst i JupyterLab-anteckningsböcker dokumentation. Mer information om hur du utforskar och visualiserar datauppsättningar finns i dokumentet om analysera dina data med bärbara datorer.

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

I den här tabellen beskrivs de valfria SQL-flaggorna som kan användas för Query Service.