Reliable Databricks Certification Associate-Developer-Apache-Spark Dumps PDF Apr 28, 2022 Kürzlich aktualisierte Fragen [Q64-Q82]

NO.64 Der unten angezeigte Codeblock enthält einen Fehler. Der Codeblock sollte einen neuen DataFrame zurückgeben, der nur Zeilen aus dem DataFrame transactionsDf enthält, in denen der Wert in der Spalte predError mindestens 5 beträgt. Finden Sie den Fehler.
Code-Block:
transactionsDf.where("col(predError) >= 5")

Das Argument für die Methode where sollte "predError >= 5" lauten.

Anstelle von where() sollte filter() verwendet werden.

Der Ausdruck gibt den ursprünglichen DataFrame transactionsDf und nicht einen neuen DataFrame zurück. Um dies zu vermeiden, sollte der Codeblock transactionsDf.toNewDataFrame().where("col(predError) >= 5") lauten.

Das Argument für die where-Methode darf keine Zeichenkette sein.

Anstelle von >= sollte der SQL-Operator GEQ verwendet werden.

NR. 65 Welcher der folgenden Codeblöcke erzeugt bei einem DataFrame transactionsDf die folgende Ausgabe?
Ausgabe:
1.Wurzel
2. |- transactionId: Ganzzahl (nullable = true)
3. |- predError: Ganzzahl (nullable = true)
4. |- Wert: Ganzzahl (löschbar = wahr)
5. |- storeId: Ganzzahl (nullable = true)
6. |- productId: Ganzzahl (nullable = true)
7. |- f: Ganzzahl (löschbar = wahr)
DataFrame TransaktionenDf:
1.+————-+———+—–+——-+———+—-+
2.|transactionId|predError|value|storeId|productId| f|
3.+————-+———+—–+——-+———+—-+
4.| 1| 3| 4| 25| 1|null|
5.| 2| 6| 7| 2| 2|null|
6.| 3| 3| null| 25| 3|null|
7.+————-+———+—–+——-+———+—-+

transactionsDf.schema.print()

transactionsDf.rdd.printSchema()

transactionsDf.rdd.formatSchema()

transactionsDf.printSchema()

print(transactionsDf.schema)

NR. 66 Welcher der folgenden Codeblöcke gibt einen DataFrame zurück, bei dem die Spalten predError und productId aus dem DataFrame transactionsDf entfernt wurden?
Beispiel für DataFrame TransaktionenDf:
1.+————-+———+—–+——-+———+—-+
2.|transactionId|predError|value|storeId|productId|f |
3.+————-+———+—–+——-+———+—-+
4.|1 |3 |4 |25 |1 |null|
5.|2 |6 |7 |2 |2 |null|
6.|3 |3 |null |25 |3 |null|
7.+————-+———+—–+——-+———+—-+

transactionsDf.withColumnRemoved("predError", "productId")

transactionsDf.drop(["predError", "productId", "associateId"])

transactionsDf.drop("predError", "productId", "associateId")

transactionsDf.dropColumns("predError", "productId", "associateId")

transactionsDf.drop(col("predError", "productId"))

NO.67 Welche der folgenden Aussagen beschreibt einen Shuffle?

Ein Shuffle ist ein Prozess, der während eines Broadcast Hash Join ausgeführt wird.

Ein Shuffle ist ein Prozess, der Daten zwischen Executors vergleicht.

Ein Shuffle ist ein Prozess, der Daten zwischen verschiedenen Partitionen vergleicht.

Ein Shuffle ist eine Spark-Operation, die aus DataFrame.coalesce() resultiert.

Ein Shuffle ist ein Prozess, der den Executors Partitionen zuweist.

1. auswählen
2. zählen
3. col("itemNameElements")
4. >3

1. filtern
2. zählen
3. itemNameElemente
4. >=3

1. auswählen
2. zählen
3. "itemNameElements"
4. >3

1. filtern
2. Größe
3. "itemNameElements"
4. >=3
(Richtig)

1. auswählen
2. Größe
3. "itemNameElements"
4. >3

NR. 69 Welche der folgenden Eigenschaften beschreibt die Spark-Benutzeroberfläche?

Über die Spark-Benutzeroberfläche können Arbeitslasten manuell auf Executors verteilt werden.

Über die Spark-Benutzeroberfläche kann die Ausführungsgeschwindigkeit der Stufe geändert werden.

Die Registerkarte Scheduler zeigt, wie Aufträge, die von mehreren Benutzern parallel ausgeführt werden, über den Cluster verteilt werden.

In der Spark-Benutzeroberfläche gibt es eine Stelle, an der die Eigenschaft spark.executor.memory.

Einige der Registerkarten in der Spark-Benutzeroberfläche heißen Jobs, Stages, Storage, DAGs, Executors und SQL.

NR. 70 Welche der folgenden Aussagen beschreibt die Adaptive Query Execution von Spark?

Zu den Funktionen der adaptiven Abfrageausführung gehören das dynamische Zusammenführen von Shuffle-Partitionen, das dynamische Einfügen von Scan-Filtern und die dynamische Optimierung von Skew-Joins.

Adaptive Query Execution ist in Spark standardmäßig aktiviert.

Adaptive Query Execution optimiert Abfragen an Ausführungspunkten neu.

Zu den Funktionen der adaptiven Abfrageausführung gehören das dynamische Umschalten von Join-Strategien und die dynamische Optimierung von Skew-Joins.

Adaptive Query Execution gilt für alle Arten von Abfragen.

NR. 71 Welche der folgenden Aussagen zur Garbage Collection in Spark ist falsch?

Auf Informationen zur Garbage Collection kann in der Stage-Detailansicht der Spark-Benutzeroberfläche zugegriffen werden.

Die Optimierung der Garbage Collection-Leistung in Spark kann die Caching-Fähigkeit einschränken.

Die manuelle Persistierung von RDDs in Spark verhindert, dass sie garbage collected werden.

In Spark ist die Verwendung des G1-Garbage-Collectors eine Alternative zur Verwendung des Standard-Garbage-Collectors von Parallel.

Serialisierte Zwischenspeicherung ist eine Strategie zur Steigerung der Leistung der Garbage Collection.

Erläuterung
Die manuelle Persistierung von RDDs in Spark verhindert, dass sie garbage collected werden.
Diese Aussage ist falsch und daher die richtige Antwort auf die Frage. Der Garbage Collector von Spark entfernt auch persistierte Objekte, allerdings nach dem "LRU"-Prinzip. LRU steht für "least recently used".
Bei einem Garbage-Collection-Lauf werden also die Objekte, die am längsten verwendet wurden, zuerst entsorgt.
Weitere Informationen finden Sie in dem unten verlinkten StackOverflow-Beitrag.
Serialisierte Zwischenspeicherung ist eine Strategie zur Steigerung der Leistung der Garbage Collection.
Diese Aussage ist richtig. Je mehr Java-Objekte Spark während der Garbage Collection sammeln muss, desto länger dauert es. Das Speichern einer Sammlung von vielen Java-Objekten, wie z. B. ein DataFrame mit einem komplexen Schema, durch Serialisierung als ein einzelnes Byte-Array erhöht daher die Leistung. Dies bedeutet, dass die Garbage Collection bei einem serialisierten DataFrame weniger Zeit benötigt als bei einem nicht serialisierten DataFrame.
Die Optimierung der Garbage Collection-Leistung in Spark kann die Caching-Fähigkeit einschränken.
Diese Aussage ist richtig. Ein vollständiger Garbage Collection-Lauf verlangsamt eine Spark-Anwendung. Wenn man über
Mit "Tuning" der Müllabfuhr meinen wir die Verringerung der Anzahl oder Dauer dieser Verlangsamungen.
Ein vollständiger Garbage-Collection-Lauf wird ausgelöst, wenn die alte Generation des Java-Heap-Speichers fast voll ist. (Wenn Sie mit diesem Konzept nicht vertraut sind, lesen Sie den Link zu den Garbage Collection Tuning-Dokumenten weiter unten). Eine Maßnahme zur Vermeidung eines Garbage-Collection-Laufs besteht also darin, zu verhindern, dass der Old-Generation-Anteil des Heap-Speicherplatzes fast voll ist.
Um dies zu erreichen, kann man seine Größe verringern. Objekte, die größer sind als der alte Generierungsspeicher, werden dann verworfen, anstatt in dem Speicherplatz zwischengespeichert zu werden, was dazu beiträgt, dass er "fast voll" ist.
Dadurch verringert sich die Anzahl der vollständigen Garbage Collection-Läufe, was die Gesamtleistung erhöht.
Es ist jedoch unvermeidlich, dass die Objekte neu berechnet werden müssen, wenn sie benötigt werden. Dieser Mechanismus funktioniert also nur, wenn eine Spark-Anwendung zwischengespeicherte Daten so wenig wie möglich wiederverwenden muss.
Auf Informationen zur Garbage Collection kann in der Stage-Detailansicht der Spark-Benutzeroberfläche zugegriffen werden.
Diese Aussage ist richtig. Die Aufgabentabelle in der Stage-Detailansicht der Spark-Benutzeroberfläche verfügt über eine Spalte "GC Time", die die pro Aufgabe benötigte Garbage Collection-Zeit angibt.
In Spark ist die Verwendung des G1-Garbage-Collectors eine Alternative zur Verwendung des Standard-Garbage-Collectors von Parallel.
Diese Aussage ist richtig. Der G1-Garbage-Collector, auch bekannt als Garbage-First-Garbage-Collector, ist eine Alternative zum Standard-Garbage-Collector Parallel.
Während der standardmäßige Parallel Garbage Collector den Heap in einige wenige statische Regionen unterteilt, unterteilt der G1 Garbage Collector den Heap in viele kleine Regionen, die dynamisch erstellt werden. Der G1-Garbage-Collector hat bestimmte Vorteile gegenüber dem Parallel-Garbage-Collector, die die Leistung insbesondere für Spark-Workloads verbessern, die einen hohen Durchsatz und eine geringe Latenzzeit erfordern.
Der G1-Garbage-Collector ist nicht standardmäßig aktiviert, und Sie müssen Spark explizit ein Argument übergeben, um ihn zu aktivieren. Weitere Informationen über die beiden Garbage Collectors finden Sie in dem unten verlinkten Databricks-Artikel.

NR. 72 Welcher der folgenden Codeblöcke verwendet ein Schema fileSchema, um eine Parkettdatei am Speicherort filePath in einen DataFrame zu lesen?

spark.read.schema(fileSchema).format("parquet").load(filePath)

spark.read.schema("fileSchema").format("parquet").load(filePath)

spark.read().schema(fileSchema).parquet(filePath)

spark.read().schema(fileSchema).format(parquet).load(filePath)

spark.read.schema(fileSchema).open(filePath)

NR. 73 Der unten angezeigte Codeblock enthält einen Fehler. Der Codeblock sollte DataFrame transactionsDf unter dem Pfad path als Parkettdatei speichern und an eine vorhandene Parkettdatei anhängen. Finden Sie den Fehler.
Code-Block:

transactionsDf.format("parquet").option("mode", "append").save(path)

Im Codeblock fehlt ein Verweis auf den DataFrameWriter.

save() wird träge ausgewertet und muss von einer Aktion gefolgt werden.

Die Option mode sollte weggelassen werden, damit der Befehl den Standardmodus verwendet.

Dem Codeblock fehlt ein bucketBy-Befehl, der sich um die Partitionen kümmert.

Da der DataFrame als Parkettdatei gespeichert werden soll, wird der Pfad an die falsche Methode übergeben.

NO.74 Welcher der folgenden Punkte beschreibt einen Unterschied zwischen dem Cluster- und dem Client-Ausführungsmodus von Spark?

Im Clustermodus befindet sich der Clustermanager auf einem Arbeitsknoten, während er im Clientmodus auf einem Randknoten liegt.

Im Clustermodus laufen die Executor-Prozesse auf Worker-Knoten, während sie im Client-Modus auf Gateway-Knoten laufen.

Im Clustermodus befindet sich der Treiber auf einem Arbeitsknoten, während er sich im Clientmodus auf einem Edge-Knoten befindet.

Im Clustermodus wird der Treiber von einem Gateway-Rechner gehostet, während er sich im Client-Modus zusammen mit dem Executor befindet.

Im Clustermodus ist der Spark-Treiber nicht mit dem Clustermanager verbunden, während er im Clientmodus mit ihm verbunden ist.

Erläuterung
Im Clustermodus befindet sich der Treiber auf einem Arbeitsknoten, während er sich im Clientmodus auf einem Edge-Knoten befindet.
Richtig. Die Idee des Client-Modus von Spark ist, dass Arbeitslasten von einem Edge-Knoten, auch Gateway-Maschine genannt, von außerhalb des Clusters ausgeführt werden können. Die häufigste Art, Spark auszuführen, ist jedoch der Clustermodus, bei dem sich der Treiber auf einem Arbeitsknoten befindet.
In der Praxis ist die Datenübertragungsgeschwindigkeit im Client-Modus im Vergleich zur Datenübertragungsgeschwindigkeit zwischen den Arbeitsknoten des Clusters stark eingeschränkt. Außerdem schlägt jeder Auftrag, der im Client-Modus ausgeführt wird, fehl, wenn der Edge-Node ausfällt. Aus diesen Gründen wird der Client-Modus in der Regel nicht in einer Produktionsumgebung verwendet.
Im Clustermodus befindet sich der Clustermanager auf einem Arbeitsknoten, während er sich im Client-Ausführungsmodus auf einem Randknoten befindet.
Nein. In beiden Ausführungsmodi kann sich der Clustermanager auf einem Arbeitsknoten befinden, jedoch nicht auf einem Edge-Knoten im Client-Modus.
Im Clustermodus laufen die Executor-Prozesse auf Worker-Knoten, während sie im Client-Modus auf Gateway-Knoten laufen.
Dies ist falsch. Auf Gateway-Knoten (auch als "Edge Nodes" bezeichnet) läuft nur der Treiber im Client-Modus, nicht aber die Executor-Prozesse.
Im Clustermodus ist der Spark-Treiber nicht mit dem Clustermanager verbunden, während er im Clientmodus mit ihm verbunden ist.
Nein, im Client-Modus befindet sich der Spark-Treiber nicht zusammen mit dem Treiber. Der Sinn des Client-Modus besteht darin, dass sich der Treiber außerhalb des Clusters befindet und nicht mit der Ressource verbunden ist, die den Cluster verwaltet (der Rechner, auf dem der Cluster-Manager läuft).
Im Clustermodus wird der Treiber von einem Gateway-Rechner gehostet, während er sich im Client-Modus zusammen mit dem Executor befindet.
Nein, es ist genau das Gegenteil der Fall: Im Clustermodus gibt es keine Gateway-Rechner, aber im Client-Modus hosten sie den Treiber.

NO.75 Welcher der folgenden Codeblöcke zeigt verschiedene aggregierte Statistiken für alle Spalten im DataFrame transactionsDf an, einschließlich der Standardabweichung und des Minimums der Werte in jeder Spalte?

transactionsDf.summary()

transactionsDf.agg("count", "mean", "stddev", "25%", "50%", "75%", "min")

transactionsDf.summary("count", "mean", "stddev", "25%", "50%", "75%", "max").show()

transactionsDf.agg("count", "mean", "stddev", "25%", "50%", "75%", "min").show()

transactionsDf.summary().show()

NR. 76 Der unten angezeigte Codeblock enthält einen Fehler. Der Codeblock soll DataFrame itemsDf mit dem größeren DataFrame transactionsDf über die Spalte itemId verbinden. Finden Sie den Fehler.
Code-Block:
transactionsDf.join(itemsDf, "itemId", how="broadcast")

Die Syntax ist falsch, how= sollte aus dem Codeblock entfernt werden.

Die Join-Methode sollte durch die Broadcast-Methode ersetzt werden.

Spark führt den Broadcast-Vorgang nur aus, wenn dieses Verhalten auf dem Spark-Cluster aktiviert wurde.

Es wird der größere DataFrame transactionsDf und nicht der kleinere DataFrame itemsDf übertragen.

broadcast ist kein gültiger Join-Typ.

NR. 77 Welcher der folgenden Codeblöcke speichert einen Teil der Daten in DataFrame itemsDf auf Executors?

itemsDf.cache().count()

itemsDf.cache(eager=True)

cache(itemsDf)

itemsDf.cache().filter()

itemsDf.rdd.storeCopy()

NO.78 Welcher der folgenden Codeblöcke zeigt die Struktur eines DataFrame in einer baumartigen Form, die sowohl Spaltennamen als auch Typen enthält?

1.print(itemsDf.columns)
2.print(itemsDf.types)

itemsDf.printSchema()

spark.schema(itemsDf)

itemsDf.rdd.printSchema()

itemsDf.print.schema()

NO.79 Der unten gezeigte Codeblock soll einen DataFrame mit den Spalten transactionsId, predError, value und f aus dem DataFrame transactionsDf zurückgeben. Wählen Sie die Antwort, die die Lücken im Codeblock korrekt ausfüllt, um dies zu erreichen.
transactionsDf.__1__(__2__)

1. filtern
2. "transactionId", "predError", "value", "f"

1. auswählen
2. "transactionId, predError, value, f"

1. auswählen
2. ["transactionId", "predError", "value", "f"]

1. wo
2. col("transactionId"), col("predError"), col("value"), col("f")

1. auswählen
2. col(["transactionId", "predError", "value", "f"])

NO.80 Der unten gezeigte Codeblock sollte eine Kopie des DataFrame transactionsDf mit einer hinzugefügten Spalte cos zurückgeben.
In dieser Spalte sollten die Werte in der Spalte Wert in Grad umgewandelt und der Kosinus dieser umgewandelten Werte genommen werden, gerundet auf zwei Dezimalstellen. Wählen Sie die Antwort, die die Lücken im Codeblock korrekt ausfüllt, um dies zu erreichen.
Code-Block:
transactionsDf.__1__(__2__, round(__3__(__4__(__5__)),2))

1. mitSpalte
2. col("cos")
3. weil
4. grad
5. transaktionenDf.wert

1. withColumnRenamed
2. "weil"
3. weil
4. grad
5. "transaktionenDf.wert"

1. mitSpalte
2. "weil"
3. weil
4. grad
5. transaktionenDf.wert

1. mitSpalte
2. col("cos")
3. weil
4. grad
5. col("Wert")
E
. 1. mitSpalte
2. "weil"
3. grad
4. weil
5. col("Wert")

itemsDf.select(explode("attributes").alias("attributes_exploded")).filter(attributes_exploded.contains("i"))

itemsDf.explode(attributes).alias("attributes_exploded").filter(col("attributes_exploded").contains("i"))

itemsDf.select(explode("attributes")).filter("attributes_exploded".contains("i"))

itemsDf.select(explode("attributes").alias("attributes_exploded")).filter(col("attributes_exploded").contain

itemsDf.select(col("attributes").explode().alias("attributes_exploded")).filter(col("attributes_exploded").co

NR. 82 Welcher der folgenden Codeblöcke gibt einen neuen DataFrame zurück, in dem die Spaltenattribute des DataFrame itemsDf in feature0 und die Spalte supplier in feature1 umbenannt sind?

itemsDf.withColumnRenamed(attributes, feature0).withColumnRenamed(supplier, feature1)

1.itemsDf.withColumnRenamed("attributes", "feature0")
2.itemsDf.withColumnRenamed("Lieferant", "Merkmal1")

itemsDf.withColumnRenamed(col("attributes"), col("feature0"), col("supplier"), col("feature1"))

itemsDf.withColumnRenamed("attributes", "feature0").withColumnRenamed("supplier", "feature1")

itemsDf.withColumn("attributes", "feature0").withColumn("supplier", "feature1")

Zuverlässige Databricks Zertifizierung Associate-Developer-Apache-Spark Dumps PDF Apr 28, 2022 Kürzlich aktualisierte Fragen [Q64-Q82]

Zuverlässige Databricks Zertifizierung Associate-Developer-Apache-Spark Dumps PDF Apr 28, 2022 Kürzlich aktualisierte Fragen [Q64-Q82]

TrainingDump

Eine Antwort hinterlassen
Antworten abbrechen

Eine Antwort hinterlassen

Zuverlässige Databricks Zertifizierung Associate-Developer-Apache-Spark Dumps PDF Apr 28, 2022 Kürzlich aktualisierte Fragen [Q64-Q82]

TrainingDump

Eine Antwort hinterlassen Antworten abbrechen

Eine Antwort hinterlassen

Eine Antwort hinterlassen
Antworten abbrechen