Ray gebruiken in Azure Databricks
Met Ray 2.3.0 en hoger kunt u Ray-clusters maken en Ray-toepassingen uitvoeren op Apache Spark-clusters met Azure Databricks. Zie de Ray-documentatie voor informatie over hoe u aan de slag gaat met machine learning op Ray, inclusief zelfstudies en voorbeelden. Zie de documentatie van Ray on Spark API voor meer informatie over de Integratie van Ray en Apache Spark.
Vereisten
- Databricks Runtime 12.2 LTS ML en hoger.
- De toegangsmodus voor databricks Runtime-clusters moet de modus Toegewezen of de modus Geen isolatie gedeeld zijn.
Ray installeren
Gebruik de volgende opdracht om Ray te installeren. De [default] extensie is vereist voor het Ray-dashboardonderdeel.
%pip install ray[default]>=2.3.0
Een gebruikersspecifiek Ray-cluster maken in een Databricks-cluster
Gebruik de ray.util.spark.setup_ray_cluster-API om een Ray-cluster te maken.
In elk Databricks-notebook dat is gekoppeld aan een Databricks-cluster, kunt u de volgende opdracht uitvoeren:
from ray.util.spark import setup_ray_cluster, shutdown_ray_cluster
setup_ray_cluster(
num_worker_nodes=2,
num_cpus_worker_node=4,
collect_log_to_path="/dbfs/path/to/ray_collected_logs"
)
De ray.util.spark.setup_ray_cluster API maakt een Ray-cluster in Spark. Intern wordt er een Spark-achtergrondtaak gemaakt. Elke Spark-taak in de taak maakt een Ray-werkknooppunt en het Ray-hoofdknooppunt wordt gemaakt op het stuurprogramma. Het argument num_worker_nodes vertegenwoordigt het aantal Ray-werkknooppunten dat moet worden gemaakt. Als u het aantal CPU- of GPU-kernen wilt opgeven dat aan elk Ray-werkknooppunt is toegewezen, stelt u het argument num_cpus_worker_node in (standaardwaarde: 1) of num_gpus_worker_node (standaardwaarde: 0).
Nadat een Ray-cluster is gemaakt, kunt u elke Ray-toepassingscode rechtstreeks in uw notebook uitvoeren. Klik op Ray Cluster Dashboard openen op een nieuw tabblad om het Ray-dashboard voor het cluster weer te geven.
Tip
Als u een Azure Databricks-cluster met één gebruiker gebruikt, kunt u instellen num_worker_nodes dat ray.util.spark.MAX_NUM_WORKER_NODES alle beschikbare resources voor uw Ray-cluster worden gebruikt.
setup_ray_cluster(
# ...
num_worker_nodes=ray.util.spark.MAX_NUM_WORKER_NODES,
)
Stel het argument collect_log_to_path in om het doelpad op te geven waar u de Ray-clusterlogboeken wilt verzamelen. Logboekverzameling wordt uitgevoerd nadat het Ray-cluster is afgesloten. Databricks raadt u aan een pad in te stellen dat begint /dbfs/ , zodat de logboeken behouden blijven, zelfs als u het Spark-cluster beëindigt. Anders kunnen uw logboeken niet worden hersteld omdat de lokale opslag op het cluster wordt verwijderd wanneer het cluster wordt afgesloten.
Notitie
"Als u wilt dat uw Ray-toepassing automatisch het Ray-cluster gebruikt dat is gemaakt, roept ray.util.spark.setup_ray_cluster u aan om de RAY_ADDRESS omgevingsvariabele in te stellen op het adres van het Ray-cluster." U kunt een alternatief clusteradres opgeven met behulp van het address argument van de ray.init-API .
Een Ray-toepassing uitvoeren
Nadat het Ray-cluster is gemaakt, kunt u elke Ray-toepassingscode uitvoeren in een Azure Databricks-notebook.
Belangrijk
Databricks raadt u aan om alle benodigde bibliotheken voor uw toepassing %pip install <your-library-dependency> te installeren om ervoor te zorgen dat ze beschikbaar zijn voor uw Ray-cluster en toepassing dienovereenkomstig. Als u afhankelijkheden opgeeft in de functie-aanroep van Ray init, worden de afhankelijkheden op een locatie niet toegankelijk voor de Spark-werkknooppunten geïnstalleerd, wat resulteert in oncompatibiliteit van de versie en importfouten.
U kunt bijvoorbeeld als volgt een eenvoudige Ray-toepassing uitvoeren in een Azure Databricks-notebook:
import ray
import random
import time
from fractions import Fraction
ray.init()
@ray.remote
def pi4_sample(sample_count):
"""pi4_sample runs sample_count experiments, and returns the
fraction of time it was inside the circle.
"""
in_count = 0
for i in range(sample_count):
x = random.random()
y = random.random()
if x*x + y*y <= 1:
in_count += 1
return Fraction(in_count, sample_count)
SAMPLE_COUNT = 1000 * 1000
start = time.time()
future = pi4_sample.remote(sample_count=SAMPLE_COUNT)
pi4 = ray.get(future)
end = time.time()
dur = end - start
print(f'Running {SAMPLE_COUNT} tests took {dur} seconds')
pi = pi4 * 4
print(float(pi))
Een Ray-cluster maken in de modus voor automatisch schalen
In Ray 2.8.0 en hoger zijn Ray-clusters gestart op Databricks ondersteuning voor integratie met automatische schaalaanpassing van Databricks. Zie Automatische schaalaanpassing van Databricks-clusters.
Met Ray 2.8.0 en hoger kunt u een Ray-cluster maken op een Databricks-cluster dat ondersteuning biedt voor omhoog of omlaag schalen op basis van workloads. Met deze integratie voor automatisch schalen wordt automatisch schalen van Databricks-clusters intern geactiveerd in de Databricks-omgeving.
Voer de volgende opdracht uit om automatisch schalen in te schakelen:
from ray.util.spark import setup_ray_cluster
setup_ray_cluster(
num_worker_nodes=8,
autoscale=True,
... # other arguments
)
Als automatisch schalen is ingeschakeld, num_worker_nodes geeft u het maximum aantal Ray-werkknooppunten aan. Het standaard minimumaantal Ray-werkknooppunten is 0. Deze standaardinstelling betekent dat wanneer het Ray-cluster inactief is, het omlaag wordt geschaald naar nul Ray-werkknooppunten. Dit is mogelijk niet ideaal voor snelle reactietijd in alle scenario's, maar wanneer ingeschakeld, kunnen de kosten aanzienlijk worden verlaagd.
In de modus num_worker_nodes voor automatisch schalen kan niet worden ingesteld op ray.util.spark.MAX_NUM_WORKER_NODES.
Met de volgende argumenten configureert u de schaalaanpassings- en downscalingsnelheid:
autoscale_upscaling_speedvertegenwoordigt het aantal knooppunten dat in behandeling is als een veelvoud van het huidige aantal knooppunten. Hoe hoger de waarde, hoe agressiever de upscaling. Als dit bijvoorbeeld is ingesteld op 1,0, kan het cluster op elk gewenst moment groter worden dan 100%.autoscale_idle_timeout_minutesgeeft het aantal minuten aan dat moet worden doorgegeven voordat een niet-actief werkknooppunt wordt verwijderd door de automatische schaalaanpassing. Hoe kleiner de waarde, hoe agressiever de schaalaanpassing.
Met Ray 2.9.0 en hoger kunt u ook instellen autoscale_min_worker_nodes dat het Ray-cluster niet kan worden geschaald naar nul werkrollen wanneer het Ray-cluster niet actief is.
Verbinding maken naar een extern Ray-cluster met behulp van de Ray-client
Maak in Ray 2.9.3 een Ray-cluster door de setup_ray_cluster API aan te roepen. Roep in hetzelfde notebook de ray.init() API aan om verbinding te maken met dit Ray-cluster.
Voor een Ray-cluster dat zich niet in de globale modus bevindt, haalt u de externe verbindingsreeks op met de volgende code:
Ga als volgt te werk om de externe verbindingsreeks op te halen:
from ray.util.spark import setup_ray_cluster
_, remote_conn_str = setup_ray_cluster(num_worker_nodes=2, ...)
Verbinding maken naar het externe cluster met behulp van deze externe verbindingsreeks:
import ray
ray.init(remote_conn_str)
De Ray-client biedt geen ondersteuning voor de Ray-gegevensset-API die in de ray.data module is gedefinieerd. Als tijdelijke oplossing kunt u uw code verpakken die de Ray-gegevensset-API aanroept in een externe Ray-taak, zoals wordt weergegeven in de volgende code:
import ray
import pandas as pd
ray.init("ray://<ray_head_node_ip>:10001")
@ray.remote
def ray_data_task():
p1 = pd.DataFrame({'a': [3,4] * 10000, 'b': [5,6] * 10000})
ds = ray.data.from_pandas(p1)
return ds.repartition(4).to_pandas()
ray.get(ray_data_task.remote())
Gegevens laden vanuit een Spark DataFrame
Als u een Spark DataFrame wilt laden als een Ray-gegevensset, moet u eerst het Spark DataFrame opslaan in UC-volumes of databricks-bestandssysteem (afgeschaft) als Parquet-indeling. Databricks Filesystem-toegang veilig beheren, raadt Databricks aan om cloudobjectopslag te koppelen aan DBFS. Vervolgens kunt u een ray.data.Dataset exemplaar maken op basis van het opgeslagen Spark DataFrame-pad met behulp van de volgende helpermethode:
import ray
import os
from urllib.parse import urlparse
def create_ray_dataset_from_spark_dataframe(spark_dataframe, dbfs_tmp_path):
spark_dataframe.write.mode('overwrite').parquet(dbfs_tmp_path)
fuse_path = "/dbfs" + urlparse(dbfs_tmp_path).path
return ray.data.read_parquet(fuse_path)
# For example, read a Delta Table as a Spark DataFrame
spark_df = spark.read.table("diviner_demo.diviner_pedestrians_data_500")
# Provide a dbfs location to write the table to
data_location_2 = (
"dbfs:/home/example.user@databricks.com/data/ray_test/test_data_2"
)
# Convert the Spark DataFrame to a Ray dataset
ray_dataset = create_ray_dataset_from_spark_dataframe(
spark_dataframe=spark_df,
dbfs_tmp_path=data_location_2
)
Gegevens uit een Unity Catalog-tabel laden via Databricks SQL Warehouse
Voor Ray 2.8.0 en hoger kunt u de ray.data.read_databricks_tables API aanroepen om gegevens uit een Databricks Unity Catalog-tabel te laden.
Eerst moet u de DATABRICKS_TOKEN omgevingsvariabele instellen op uw Databricks-toegangstoken. Als u uw programma niet uitvoert in Databricks Runtime, stelt u de DATABRICKS_HOST omgevingsvariabele in op de URL van de Databricks-werkruimte, zoals wordt weergegeven in het volgende:
export DATABRICKS_HOST=adb-<workspace-id>.<random-number>.azuredatabricks.net
ray.data.read_databricks_tables() Roep vervolgens aan om te lezen vanuit het Databricks SQL-warehouse.
import ray
ray_dataset = ray.data.read_databricks_tables(
warehouse_id='...', # Databricks SQL warehouse ID
catalog='catalog_1', # Unity catalog name
schema='db_1', # Schema name
query="SELECT title, score FROM movie WHERE year >= 1980",
)
Resources configureren die worden gebruikt door ray-hoofdknooppunt
Voor de Ray on Spark-configuratie beperkt Databricks standaard resources die zijn toegewezen aan het Ray-hoofdknooppunt tot:
- 0 CPU-kernen
- 0 GPU's
- Heap-geheugen van 128 MB
- Geheugen voor objectopslag van 128 MB
Dit komt doordat het Ray-hoofdknooppunt meestal wordt gebruikt voor wereldwijde coördinatie, niet voor het uitvoeren van Ray-taken. De resources van het Spark-stuurprogrammaknooppunt worden gedeeld met meerdere gebruikers, dus met de standaardinstelling worden resources opgeslagen aan de kant van het Spark-stuurprogramma.
Met Ray 2.8.0 en hoger kunt u resources configureren die worden gebruikt door het Ray-hoofdknooppunt. Gebruik de volgende argumenten in de setup_ray_cluster API:
num_cpus_head_node: cpu-kernen instellen die worden gebruikt door ray-hoofdknooppuntnum_gpus_head_node: GPU instellen die wordt gebruikt door ray-hoofdknooppuntobject_store_memory_head_node: het instellen van de geheugengrootte van het objectarchief per Ray-hoofdknooppunt
Ondersteuning voor heterogene clusters
Voor efficiëntere en rendabele trainingsuitvoeringen kunt u een Ray op Spark-cluster maken en verschillende configuraties instellen tussen het Ray-hoofdknooppunt en de Ray-werkknooppunten. Alle Ray-werkknooppunten moeten echter dezelfde configuratie hebben. Databricks-clusters bieden geen volledige ondersteuning voor heterogene clusters, maar u kunt een Databricks-cluster maken met verschillende typen stuurprogramma- en werkrolexemplaren door een clusterbeleid in te stellen.
Voorbeeld:
{
"node_type_id": {
"type": "fixed",
"value": "i3.xlarge"
},
"driver_node_type_id": {
"type": "fixed",
"value": "g4dn.xlarge"
},
"spark_version": {
"type": "fixed",
"value": "13.x-snapshot-gpu-ml-scala2.12"
}
}
De configuratie van het Ray-cluster afstemmen
De aanbevolen configuratie voor elk Ray-werkknooppunt is:
- Minimaal 4 CPU-kernen per Ray-werkknooppunt.
- Minimaal 10 GB heap-geheugen voor elk Ray Worker-knooppunt.
Wanneer u aanroept ray.util.spark.setup_ray_cluster, raadt Databricks aan om de instelling in te stellen num_cpus_worker_node op een waarde >= 4.
Zie Geheugentoewijzing voor Ray-werkknooppunten voor meer informatie over het afstemmen van heap-geheugen voor elk Ray-werkknooppunt.
Geheugentoewijzing voor Ray-werkknooppunten
Elk Ray-werkknooppunt maakt gebruik van twee soorten geheugen: heapgeheugen en objectopslaggeheugen. De toegewezen geheugengrootte voor elk type wordt bepaald zoals hieronder wordt beschreven.
Het totale geheugen dat aan elk Ray Worker-knooppunt is toegewezen, is:
RAY_WORKER_NODE_TOTAL_MEMORY = (SPARK_WORKER_NODE_PHYSICAL_MEMORY / MAX_NUMBER_OF_LOCAL_RAY_WORKER_NODES * 0.8)
MAX_NUMBER_OF_LOCAL_RAY_WORKER_NODES is het maximum aantal Ray-werkknooppunten dat kan worden gestart op het Spark-werkknooppunt. Dit wordt bepaald door het argument num_cpus_worker_node of num_gpus_worker_node.
Als u het argument object_store_memory_per_nodeniet instelt, zijn de heap-geheugengrootte en objectopslaggeheugengrootte toegewezen aan elk Ray-werkknooppunt:
RAY_WORKER_NODE_HEAP_MEMORY = RAY_WORKER_NODE_TOTAL_MEMORY * 0.7
OBJECT_STORE_MEMORY_PER_NODE = RAY_WORKER_NODE_TOTAL_MEMORY * 0.3
Als u het argument object_store_memory_per_nodeinstelt:
RAY_WORKER_NODE_HEAP_MEMORY = RAY_WORKER_NODE_TOTAL_MEMORY - argument_object_store_memory_per_node
Daarnaast wordt de geheugengrootte van het object opgeslagen per Ray Worker-knooppunt beperkt door het gedeelde geheugen van het besturingssysteem. De maximumwaarde is:
OBJECT_STORE_MEMORY_PER_NODE_CAP = (SPARK_WORKER_NODE_OS_SHARED_MEMORY / MAX_NUMBER_OF_LOCAL_RAY_WORKER_NODES * 0.8)
SPARK_WORKER_NODE_OS_SHARED_MEMORY is de /dev/shm schijfgrootte die is geconfigureerd voor het Spark-werkknooppunt.
Aanbevolen procedures
Cpu-/GPU-nummer instellen voor elk Ray-werkknooppunt?
Databricks raadt aan om het aantal CPU-kernen per Spark-werkknooppunt in te stellen num_cpus_worker_node en het aantal GPU's per Spark-werkknooppunt in te stellen num_gpus_worker_node . In deze configuratie start elk Spark-werkknooppunt één Ray Worker-knooppunt dat volledig gebruikmaakt van de resources van het Spark-werkknooppunt.
Configuratie van GPU-cluster
Het Ray-cluster wordt uitgevoerd op een Databricks Spark-cluster. Een veelvoorkomend scenario is het gebruik van een Spark-taak en Spark UDF voor het uitvoeren van eenvoudige gegevensvoorverwerkingstaken die geen GPU-resources nodig hebben en vervolgens Ray gebruiken om ingewikkelde machine learning-taken uit te voeren die baat hebben bij GPU's. In dit geval raadt Databricks aan om de configuratieparameter spark.task.resource.gpu.amount op Spark-clusterniveau in te 0stellen, zodat alle Spark DataFrame-transformaties en Spark UDF-uitvoeringen geen GPU-resources gebruiken.
De voordelen van deze configuratie zijn:
- Het verhoogt het parallellisme van spark-taken, omdat het GPU-exemplaartype meestal veel meer CPU-kernen heeft dan GPU-apparaten.
- Als het Spark-cluster wordt gedeeld met meerdere gebruikers, voorkomt deze configuratie dat Spark-taken concurreren voor GPU-resources met gelijktijdig uitgevoerde Ray-workloads.
Trainer mlflow-integratie uitschakelen transformers bij gebruik in Ray-taken
De transformers trainer MLflow-integratie is standaard ingeschakeld. Als u Ray Train gebruikt om deze te trainen, mislukt de Ray-taak omdat de Databricks MLflow-servicereferentie niet is geconfigureerd voor Ray-taken.
Om dit probleem te voorkomen, stelt u de DISABLE_MLFLOW_INTEGRATION omgevingsvariabele in op TRUE in de configuratie van het Databricks-cluster. Zie de sectie 'MLflow gebruiken in Ray-taken' voor meer informatie over het aanmelden bij MLflow in uw Ray-trainertaken.
Fout bij het kiezen van externe functie van Ray oplossen
Om Ray-taken uit te voeren, gebruikt Ray pickle om de taakfunctie te serialiseren. Als het kiezen mislukt, bepaalt u de regel(en) in uw code waar de fout optreedt. Vaak worden met het verplaatsen import van opdrachten naar de taakfunctie veelvoorkomende pickling-fouten opgelost. Is bijvoorbeeld datasets.load_dataset een veelgebruikte functie die in Databricks Runtime wordt gepatcht, waardoor een externe import mogelijk niet kan worden geselecteerd. U kunt dit probleem oplossen door uw code als volgt bij te werken:
def ray_task_func():
from datasets import load_dataset # import the function inside task function
...
Ray-geheugenmonitor uitschakelen als de Ray-taak onverwacht wordt gedood met een OOM-fout
In Ray 2.9.3 heeft de Ray-geheugenmonitor bekende problemen waardoor Ray-taken ten onrechte worden gedood.
U kunt het probleem oplossen door de Ray-geheugenmonitor uit te schakelen door de omgevingsvariabele RAY_memory_monitor_refresh_ms0 in te stellen in de configuratie van het Databricks-cluster.
Configuratie van geheugenresources voor hybride Spark- en Ray-workloads
Als u hybride Spark- en Ray-workloads uitvoert in een Databricks-cluster, raadt Databricks u aan om spark-uitvoerprogramma's te verminderen tot een kleine waarde, zoals de instelling spark.executor.memory 4g in de configuratie van het Databricks-cluster. Dit is het gevolg van de Spark-uitvoerprogramma die wordt uitgevoerd in een Java-proces dat GC (garbagecollection) lazily activeert. De geheugenbelasting voor caching van Spark-gegevenssets is vrij hoog, waardoor het beschikbare geheugen dat Ray kan gebruiken, wordt verminderd. Om potentiële OOM-fouten te voorkomen, raadt Databricks u aan om de geconfigureerde spark.executor.memory-waarde te verminderen tot een kleinere waarde dan de standaardwaarde.
Rekenresourceconfiguratie voor hybride Spark- en Ray-workloads
Als u hybride Spark- en Ray-workloads uitvoert in een Databricks-cluster, stelt u de Spark-clusterknooppunten in op automatisch schaalbaar, de Ray-werkknooppunten op automatisch schaalbaar of beide waarvoor automatisch schalen is ingeschakeld.
Als u bijvoorbeeld een vast aantal werkknooppunten in een Databricks-cluster hebt, kunt u overwegen om automatisch schalen van Ray-on-Spark in te schakelen, zodat wanneer er geen Ray-werkbelasting wordt uitgevoerd, het Ray-cluster omlaag wordt geschaald. Als gevolg hiervan worden de niet-actieve clusterbronnen vrijgegeven, zodat de Spark-taak deze kan gebruiken.
Wanneer de Spark-taak is voltooid en de Ray-taak wordt gestart, wordt het Ray-on-Spark-cluster geactiveerd om omhoog te schalen om te voldoen aan de verwerkingsvereisten.
U kunt ook zowel het Databricks-cluster als het Ray-on-spark-cluster automatisch schaalbaar maken. U kunt het Databricks-cluster met name automatisch schaalbare knooppunten configureren op maximaal 10 knooppunten en de Ray-on-Spark-werkknooppunten tot maximaal 4 knooppunten (met één Ray-werkknooppunt per spark-werkrol), waardoor Spark maximaal 6 knooppunten voor Spark-taken kan toewijzen. Dit betekent dat Ray-workloads tegelijkertijd maximaal vier knooppuntenbronnen kunnen gebruiken, terwijl de Spark-taak maximaal 6 knooppunten aan resources kan toewijzen.
Transformatiefunctie toepassen op batches gegevens
Wanneer u gegevens in batches verwerkt, raadt Databricks u aan om de Ray Data-API met map_batches functie te gebruiken. Deze benadering kan efficiënter en schaalbaarder zijn, met name voor grote gegevenssets of bij het uitvoeren van complexe berekeningen die profiteren van batchverwerking. Elk Spark DataFrame kan worden geconverteerd naar Ray-gegevens met behulp van de ray.data.from_spark API en kan worden weggeschreven naar databricks UC-tabel met behulp van de API ray.data.write_databricks_table.
MLflow gebruiken in Ray-taken
Als u MLflow in Ray-taken wilt gebruiken, configureert u het volgende:
- Databricks MLflow-referenties in Ray-taken
- MLflow wordt uitgevoerd aan de kant van het Spark-stuurprogramma waarmee de gegenereerde
run_idwaarden worden doorgegeven aan Ray-taken.
De volgende code is een voorbeeld:
import mlflow
import ray
from mlflow.utils.databricks_utils import get_databricks_env_vars
mlflow_db_creds = get_databricks_env_vars("databricks")
experiment_name = "/Users/<your-name>@databricks.com/mlflow_test"
mlflow.set_experiment(experiment_name)
@ray.remote
def ray_task(x, run_id):
import os
os.environ.update(mlflow_db_creds)
mlflow.set_experiment(experiment_name)
# We need to use the run created in Spark driver side,
# and set `nested=True` to make it a nested run inside the
# parent run.
with mlflow.start_run(run_id=run_id, nested=True):
mlflow.log_metric(f"task_{x}_metric", x)
return x
with mlflow.start_run() as run: # create MLflow run in Spark driver side.
results = ray.get([ray_task.remote(x, run.info.run_id) for x in range(10)])
Python-bibliotheken met notebooks of python-clusterbibliotheken gebruiken in Ray-taken
Momenteel heeft Ray een bekend probleem dat Ray-taken geen Python-bibliotheken met notebookbereik of Python-clusterbibliotheken kunnen gebruiken. Als u deze beperking wilt oplossen, voert u de volgende opdracht uit in uw notebook voordat u een Ray-on-Spark-cluster start:
%pip install ray==<The Ray version you want to use> --force-reinstall
en voer vervolgens de volgende opdracht uit in uw notebook om de Python-kernel opnieuw op te starten:
dbutils.library.restartPython()
Stacktraceringen en vlamgrafieken inschakelen op de pagina Ray Dashboard Actors
Op de pagina Ray Dashboard Actors kunt u stacktraceringen en vlamdiagrammen voor actieve Ray-acteurs bekijken.
Als u deze informatie wilt bekijken, installeert py-spy u deze voordat u het Ray-cluster start:
%pip install py-spy
Een Ray-cluster afsluiten
Als u een Ray-cluster wilt afsluiten dat wordt uitgevoerd op Azure Databricks, roept u de ray.utils.spark.shutdown_ray_cluster-API aan.
Notitie
Ray-clusters worden ook afgesloten wanneer:
Voorbeeld van notebook
In het volgende notebook ziet u hoe u een Ray-cluster maakt en een Ray-toepassing uitvoert op Databricks.
Ray op Spark Starter-notebook
Beperkingen
- Gedeelde Azure Databricks-clusters met meerdere gebruikers (isolatiemodus ingeschakeld) worden niet ondersteund.
- Wanneer u %pip gebruikt om pakketten te installeren, wordt het Ray-cluster afgesloten. Zorg ervoor dat u Ray start nadat u klaar bent met het installeren van al uw bibliotheken met %pip.
- Als u integraties gebruikt waarmee de configuratie
ray.util.spark.setup_ray_clusterwordt overschreven, kan dit ertoe leiden dat het Ray-cluster instabiel wordt en de Ray-context kan vastlopen. Als u bijvoorbeeld het pakket en dexgboost_rayinstellingRayParamsgebruikt met een actor ofcpus_per_actorconfiguratie boven de ray-clusterconfiguratie, kan het Ray-cluster op de achtergrond vastlopen.