Rezept erstellen mit Jupyter Notebooks

Dieses Tutorial umfasst zwei Hauptabschnitte. First, you will create a machine learning model using a template within JupyterLab Notebook. Next, you will exercise the notebook to recipe workflow within JupyterLab to create a recipe within Data Science Workspace.

Vorgestellte Konzepte:

  • Rezepte: Ein Rezept ist ein von Adobe verwendeter Begriff für eine Modellspezifikation. Es handelt sich dabei um einen Container auf oberster Ebene, der einen bestimmten Algorithmus für maschinelles Lernen, einen KI-Algorithmus oder eine Gruppe von Algorithmen, eine Verarbeitungslogik und eine Konfiguration darstellt, die für die Einrichtung und Ausführung eines trainierten Modells und somit zur Lösung spezifischer geschäftlicher Probleme erforderlich sind.
  • Modell: Ein Modell ist eine Instanz eines maschinellen Lernrezepts, das mithilfe von historischen Daten und Konfigurationen zur Lösung eines geschäftlichen Anwendungsfalls trainiert wird.
  • Training: Ein Training besteht aus dem Erlernen von Mustern und Insights auf Grundlage gekennzeichneter Daten.
  • Scoring: Beim Scoring werden mithilfe eines trainierten Modells Insights aus Daten generiert.

Get started with the JupyterLab notebook environment

Creating a recipe from scratch can be done within Data Science Workspace. Navigieren Sie zum Beginn zu Adobe Experience Platform und klicken Sie auf der linken Seite auf die Registerkarte Notebooks . Erstellen Sie ein neues Notebook, indem Sie die Vorlage Rezept-Builder aus dem JupyterLab Launcher.

The Recipe Builder notebook allows you to run training and scoring runs inside the notebook. So können Sie zwischen laufenden Experimenten für Trainings- und Scoring-Daten flexibel Änderungen an den train()- und score()-Methoden vorzunehmen. Once you are happy with the outputs of the training and scoring, you can create a recipe to be used in Data Science Workspace using the notebook to recipe functionality built in to the Recipe Builder notebook.

HINWEIS

Das Recipe Builder-Notebook erlaubt ein Arbeiten mit allen Dateiformaten, die Funktion „Rezept erstellen“ unterstützt derzeit jedoch nur Python.

Wenn Sie vom Starter auf das Rezept Builder-Notebook klicken, wird das Notebook in der Registerkarte geöffnet. Die im Notebook verwendete Vorlage ist das Rezept „Python Retail Sales Forecasting“, das auch in diesem öffentlichen Repository zu finden ist.

You will notice that in the toolbar there are three additional actions namely – Train, Score, and Create Recipe. These icons only appear in the Recipe Builder notebook. Weiterführende Informationen zu diesen Aktionen erhalten Sie im Abschnitt Training und Scoring, nachdem Sie Ihr Rezept im Notebook erstellt haben.

Rezeptdateien bearbeiten

Um Änderungen an den Rezeptdateien vorzunehmen, navigieren Sie in Jupyter zu der Zelle, die dem Dateipfad entspricht. Wenn Sie zum Beispiel Änderungen an evaluator.py vornehmen möchten, suchen Sie nach %%writefile demo-recipe/evaluator.py.

Nehmen Sie die erforderlichen Änderungen in der Zelle vor und führen Sie die Zelle dann einfach aus. Der %%writefile filename.py-Befehl schreibt den Inhalt der Zelle in die Datei filename.py. Sie müssen die Zelle für jede Datei mit Änderungen manuell ausführen.

HINWEIS

Sie sollten die Zellen gegebenenfalls manuell ausführen.

Erste Schritte mit dem Recipe Builder-Notebook

Now that you know the basics for the JupyterLab notebook environment, you can begin looking at the files that make up a machine learning model recipe. Die Dateien, über die wir reden werden, sind hier dargestellt:

Anforderungsdatei

Die Anforderungsdatei dient zum Deklarieren zusätzlicher Bibliotheken, die Sie im Rezept verwenden möchten. Sie können die Versionsnummer angeben, wenn eine Abhängigkeit vorliegt. To look for additional libraries, visit anaconda.org. Informationen zum Formatieren der Anforderungsdatei finden Sie unter Conda. Die Liste der bereits verwendeten Hauptbibliotheken umfasst:

python=3.6.7
scikit-learn
pandas
numpy
data_access_sdk_python
HINWEIS

Bibliotheken oder spezifische Versionen, die Sie hinzufügen, sind möglicherweise nicht mit den oben genannten Bibliotheken kompatibel. Wenn Sie sich außerdem dafür entscheiden, eine Umgebung manuell zu erstellen, darf das name Feld nicht überschrieben werden.

Konfigurationsdateien

Mit den Konfigurationsdateien training.conf und scoring.conf werden die Datensätze angegeben, die Sie für das Training und Scoring sowie das Hinzufügen von Hyperparametern nutzen möchten. Es gibt separate Konfigurationen für Training und Scoring.

Benutzer müssen die folgenden Variablen ausfüllen, bevor sie ein Training und Scoring durchführen können:

  • trainingDataSetId
  • ACP_DSW_TRAINING_XDM_SCHEMA
  • scoringDataSetId
  • ACP_DSW_SCORING_RESULTS_XDM_SCHEMA
  • scoringResultsDataSetId

Um die Datensatz- und Schemakennungen zu suchen, rufen Sie in Notebooks in der linken Navigationsleiste (unter dem Ordnersymbol) die Registerkarte „Daten“ auf.

Dieselben Daten finden Sie in Adobe Experience Platform unter den Registerkarten Schema und Datensätze.

Standardmäßig sind für den Zugriff auf Daten die folgenden Konfigurationsparameter festgelegt:

  • ML_FRAMEWORK_IMS_USER_CLIENT_ID
  • ML_FRAMEWORK_IMS_TOKEN
  • ML_FRAMEWORK_IMS_ML_TOKEN
  • ML_FRAMEWORK_IMS_TENANT_ID

Ladeprogramm für Trainings-Daten

Der Zweck des Ladeprogramms für Trainings-Daten besteht darin, Daten zu instanziieren, die zum Erstellen des maschinellen Lernmodells verwendet werden. In der Regel gibt es zwei Aufgaben, die das Ladeprogramm für Trainings-Daten erledigen wird:

  • Load data from Platform
  • Datenvorbereitung und Funktionsentwicklung

Die folgenden beiden Abschnitte liefern Informationen über das Laden und Vorbereiten von Daten.

Laden von Daten

In diesem Schritt wird der pandas-Dataframe verwendet. Data can be loaded from files in Adobe Experience Platform using either the Platform SDK (platform_sdk), or from external sources using pandas' read_csv() or read_json() functions.

HINWEIS

Im Recipe Builder-Notebook werden Daten über das Datenladeprogramm platform_sdk geladen.

Platform SDK

Eine ausführliche Anleitung zur Verwendung des Datenladeprogramms platform_sdk finden Sie im Handbuch zum Platform-SDK. Dieses Tutorial enthält Informationen zur Build-Authentifizierung, zum grundlegenden Lesen von Daten sowie zum grundlegenden Schreiben von Daten.

Externe Quellen

Dieser Abschnitt veranschaulicht, wie Sie eine JSON- oder CSV-Datei in ein pandas-Objekt importieren können. Die offizielle Dokumentation der pandas-Bibliothek finden Sie hier:

Zunächst finden Sie hier ein Beispiel für den Import einer CSV-Datei. Das data-Argument ist der Pfad zur CSV-Datei. Diese Variable wurde aus den configProperties im vorherigen Abschnitt importiert.

df = pd.read_csv(data)

Sie können auch aus einer JSON-Datei importieren. Das data-Argument ist der Pfad zur CSV-Datei. Diese Variable wurde aus den configProperties im vorherigen Abschnitt importiert.

df = pd.read_json(data)

Jetzt befinden sich Ihre Daten im Dataframe-Objekt und können im nächsten Abschnitt analysiert und bearbeitet werden.

Von Plattform-SDK

Sie können Daten mit dem Plattform-SDK laden. Die Bibliothek kann oben auf der Seite importiert werden, indem die folgende Zeile eingefügt wird:

from platform_sdk.dataset_reader import DatasetReader

Anschließend nutzen wir die load()-Methode, um den Trainings-Datensatz aus der trainingDataSetId wie in unserer Konfiguration (recipe.conf) festgelegt zu erfassen.

def load(config_properties):
    print("Training Data Load Start")

    #########################################
    # Load Data
    #########################################    
    client_context = get_client_context(config_properties)
    
    dataset_reader = DatasetReader(client_context, config_properties['trainingDataSetId'])
    
    timeframe = config_properties.get("timeframe")
    tenant_id = config_properties.get("tenant_id")
HINWEIS

As mentioned in the Configuration File section, the following configuration parameters are set for you when you access data from Experience Platform using client_context:

  • ML_FRAMEWORK_IMS_USER_CLIENT_ID
  • ML_FRAMEWORK_IMS_TOKEN
  • ML_FRAMEWORK_IMS_ML_TOKEN
  • ML_FRAMEWORK_IMS_TENANT_ID

Jetzt, da Sie über Ihre Daten verfügen, können Sie mit der Datenvorbereitung und Funktionsentwicklung beginnen.

Datenvorbereitung und Funktionsentwicklung

Nach dem Laden werden die Daten vorbereitet und auf die Datensätze train und val aufgeteilt. Betrachten Sie folgenden Beispiel-Code:

#########################################
# Data Preparation/Feature Engineering
#########################################
dataframe.date = pd.to_datetime(dataframe.date)
dataframe['week'] = dataframe.date.dt.week
dataframe['year'] = dataframe.date.dt.year

dataframe = pd.concat([dataframe, pd.get_dummies(dataframe['storeType'])], axis=1)
dataframe.drop('storeType', axis=1, inplace=True)
dataframe['isHoliday'] = dataframe['isHoliday'].astype(int)

dataframe['weeklySalesAhead'] = dataframe.shift(-45)['weeklySales']
dataframe['weeklySalesLag'] = dataframe.shift(45)['weeklySales']
dataframe['weeklySalesDiff'] = (dataframe['weeklySales'] - dataframe['weeklySalesLag']) / dataframe['weeklySalesLag']
dataframe.dropna(0, inplace=True)

dataframe = dataframe.set_index(dataframe.date)
dataframe.drop('date', axis=1, inplace=True)

In diesem Beispiel werden auf den ursprünglichen Datensatz fünf Aktionen angewendet:

  • Hinzufügen der Spalten week und year
  • Konvertieren von storeType in eine Indikatorvariable
  • Konvertieren von isHoliday in eine numerische Variable
  • Versetzen von weeklySales für zukünftige und vorherige Umsatzwerte
  • Aufteilen von Daten anhand des Datums in die Datensätze train und val

First, week and year columns are created and the original date column converted to Python datetime. Wochen- und Jahreswerte werden aus dem datetime-Objekt extrahiert.

Dann wird storeType in drei Spalten konvertiert, die die drei verschiedenen Speichertypen (A, B und C) darstellen. Jede wird einen booleschen Wert für den Status enthalten, wobei storeType „true“ lautet. Die storeType-Spalte wird verworfen.

Gleichermaßen ändert weeklySales den booleschen Wert isHoliday in eine numerische Darstellung (eins oder null).

Diese Daten werden auf die Datensätze train und val aufgeteilt.

Die load()-Funktion sollte mit den Datensätzen train und val als Ausgabe abgeschlossen werden.

Ladeprogramm für Scoring-Daten

Das Laden von Daten zum Scoring ähnelt dem Laden von Trainings-Daten in der split()-Funktion. Wir verwenden das Data Access-SDK, um Daten aus der scoringDataSetId in unserer recipe.conf-Datei zu laden.

def load(config_properties):

    print("Scoring Data Load Start")

    #########################################
    # Load Data
    #########################################
    client_context = get_client_context(config_properties)

    dataset_reader = DatasetReader(client_context, config_properties['scoringDataSetId'])
    timeframe = config_properties.get("timeframe")
    tenant_id = config_properties.get("tenant_id")

Nach dem Laden der Daten erfolgen die Datenvorbereitung und Funktionsentwicklung.

    #########################################
    # Data Preparation/Feature Engineering
    #########################################
    if '_id' in dataframe.columns:
        #Rename columns to strip tenantId
        dataframe = dataframe.rename(columns = lambda x : str(x)[str(x).find('.')+1:])
        #Drop id, eventType and timestamp
        dataframe.drop(['_id', 'eventType', 'timestamp'], axis=1, inplace=True)

    dataframe.date = pd.to_datetime(dataframe.date)
    dataframe['week'] = dataframe.date.dt.week
    dataframe['year'] = dataframe.date.dt.year

    dataframe = pd.concat([dataframe, pd.get_dummies(dataframe['storeType'])], axis=1)
    dataframe.drop('storeType', axis=1, inplace=True)
    dataframe['isHoliday'] = dataframe['isHoliday'].astype(int)

    dataframe['weeklySalesAhead'] = dataframe.shift(-45)['weeklySales']
    dataframe['weeklySalesLag'] = dataframe.shift(45)['weeklySales']
    dataframe['weeklySalesDiff'] = (dataframe['weeklySales'] - dataframe['weeklySalesLag']) / dataframe['weeklySalesLag']
    dataframe.dropna(0, inplace=True)

    dataframe = dataframe.set_index(dataframe.date)
    dataframe.drop('date', axis=1, inplace=True)

    print("Scoring Data Load Finish")

    return dataframe

Da der Zweck unseres Modells darin besteht, zukünftige Wochenumsätze vorherzusagen, müssen Sie einen Scoring-Datensatz erstellen, um zu bewerten, wie gut die Prognosen des Modells funktionieren.

Dieses Recipe Builder-Notebook erlaubt das, indem unser Wochenumsatz (weeklySales) um 7 Tage nach vorne versetzt wird. Beachten Sie, dass es wöchentliche Messwerte für 45 Filialen gibt, sodass Sie die weeklySales-Werte in einer neuen Spalte namens weeklySalesAhead um 45 Datensätze nach vorne verschieben können.

df['weeklySalesAhead'] = df.shift(-45)['weeklySales']

Auf ähnliche Weise können Sie eine Spalte weeklySalesLag erstellen, indem Sie eine Verschiebung um 45 nach hinten vornehmen. So können Sie auch den Unterschied bei Wochenumsätzen berechnen und in der Spalte weeklySalesDiff speichern.

df['weeklySalesLag'] = df.shift(45)['weeklySales']
df['weeklySalesDiff'] = (df['weeklySales'] - df['weeklySalesLag']) / df['weeklySalesLag']

Da Sie die weeklySales-Datenpunkte um 45 Datensätze nach vorne und 45 Datensätze nach hinten versetzen, um neue Spalten zu erstellen, weisen die ersten und letzten 45 Datenpunkte NaN-Werte auf. Sie können diese Punkte aus unserem Datensatz entfernen, indem Sie die df.dropna()-Funktion verwenden, um alle Zeilen mit NaN-Werten zu entfernen.

df.dropna(0, inplace=True)

Die load()-Funktion in Ihrem Ladeprogramm für Scoring-Daten sollte mit dem Scoring-Datensatz als Ausgabe abschließen.

Pipeline-Datei

Die pipeline.py-Datei enthält Logiken für Training und Scoring.

Training

Der Zweck von Training besteht darin, mithilfe von Funktionen und Bezeichnungen in Ihrem Trainings-Datensatz ein Modell zu erstellen.

HINWEIS

Funktionen bezieht sich auf die Eingabevariable, die vom maschinellen Lernmodell zur Vorhersage der Bezeichnungen verwendet wird.

Die train()-Funktion sollte das Trainings-Modell enthalten und das trainierte Modell zurückgeben. Beispiele für verschiedene Modelle finden Sie in der Dokumentation Benutzerhandbuch zu scikit-learn.

Nach der Auswahl Ihres Trainings-Modells passen Sie Ihren x- und y-Trainings-Datensatz an das Modell an und die Funktion gibt das trainierte Modell zurück. Folgendes Beispiel veranschaulicht zeigt dies:

def train(configProperties, data):

    print("Train Start")

    #########################################
    # Extract fields from configProperties
    #########################################
    learning_rate = float(configProperties['learning_rate'])
    n_estimators = int(configProperties['n_estimators'])
    max_depth = int(configProperties['max_depth'])


    #########################################
    # Fit model
    #########################################
    X_train = data.drop('weeklySalesAhead', axis=1).values
    y_train = data['weeklySalesAhead'].values

    seed = 1234
    model = GradientBoostingRegressor(learning_rate=learning_rate,
                                      n_estimators=n_estimators,
                                      max_depth=max_depth,
                                      random_state=seed)

    model.fit(X_train, y_train)

    print("Train Complete")

    return model

Beachten Sie, dass je nach Anwendung Argumente in Ihrer GradientBoostingRegressor()-Funktion vorhanden sind. xTrainingDataset sollte Ihre für das Training genutzten Funktionen enthalten, während yTrainingDataset die Bezeichnungen beinhalten sollte.

Scoring

Die score()-Funktion sollte den Scoring-Algorithmus enthalten und einen Messwert zurückgeben, der angibt, wie gut das Modell funktioniert. Die score()-Funktion nutzt die Bezeichnungen des Scoring-Datensatzes und das trainierte Modell, um eine Reihe von prognostizierten Funktionen zu generieren. Die prognostizierten Werte werden dann mit den tatsächlichen Funktionen im Scoring-Datensatz abgeglichen. In diesem Beispiel verwendet die Funktion score() das trainierte Modell, um Funktionen mithilfe der Bezeichnungen aus dem Scoring-Datensatz vorherzusagen. Die prognostizierten Funktionen werden zurückgegeben.

def score(configProperties, data, model):

    print("Score Start")

    X_test = data.drop('weeklySalesAhead', axis=1).values
    y_test = data['weeklySalesAhead'].values
    y_pred = model.predict(X_test)

    data['prediction'] = y_pred
    data = data[['store', 'prediction']].reset_index()
    data['date'] = data['date'].astype(str)

    print("Score Complete")

    return data

Evaluator-Datei

Die evaluator.py-Datei enthält eine Logik dafür, wie Sie Ihr trainiertes Rezept bewerten und die Trainings-Daten aufteilen wollen. Für das Einzelhandelsbeispiel wird die Logik zum Laden und Vorbereiten der Trainings-Daten einbezogen. Wir sehen uns die beiden folgenden Abschnitte an.

Datensatz aufteilen

Die Vorbereitung der Daten für das Training erfordert eine Aufteilung des Datensatzes, damit er sich für Training und Tests verwenden lässt. Diese val-Daten dienen implizit dazu, das Modell nach dem Trainieren zu bewerten. Dieser Prozess erfolgt getrennt vom Scoring.

Dieser Abschnitt veranschaulicht die split()-Funktion, die zuerst Daten in das Notebook lädt und dann bereinigt, indem nicht verwandte Spalten im Datensatz entfernt werden. Nun können Sie mit der Funktionsentwicklung fortfahren; sie erlaubt die Erstellung zusätzlicher relevanter Funktionen aus vorhandenen Rohfunktionen in den Daten. Ein Beispiel für diesen Vorgang sowie eine entsprechende Erklärung finden Sie im Folgenden.

Die split()-Funktion ist unten dargestellt. Der im Argument bereitgestellte Dataframe wird in die zurückzugebenden Variablen train und val aufgeteilt.

def split(self, configProperties={}, dataframe=None):
    train_start = '2010-02-12'
    train_end = '2012-01-27'
    val_start = '2012-02-03'
    train = dataframe[train_start:train_end]
    val = dataframe[val_start:]

    return train, val

Trainiertes Modell bewerten

Die evaluate()-Funktion wird ausgeführt, nachdem das Modell trainiert wurde, und gibt einen Messwert zurück, der angibt, wie gut das Modell funktioniert. Die evaluate()-Funktion nutzt die Testdatensatzbezeichnungen und das trainierte Modell, um eine Reihe von Funktionen vorherzusagen. Die prognostizierten Werte werden dann mit den tatsächlichen Funktionen im Testdatensatz abgeglichen. Häufige Scoring-Algorithmen sind:

Die evaluate()-Funktion im Beispiel für Einzelhandelsumsätze ist unten dargestellt:

def evaluate(self, data=[], model={}, configProperties={}):
    print ("Evaluation evaluate triggered")
    val = data.drop('weeklySalesAhead', axis=1)
    y_pred = model.predict(val)
    y_actual = data['weeklySalesAhead'].values
    mape = np.mean(np.abs((y_actual - y_pred) / y_actual))
    mae = np.mean(np.abs(y_actual - y_pred))
    rmse = np.sqrt(np.mean((y_actual - y_pred) ** 2))

    metric = [{"name": "MAPE", "value": mape, "valueType": "double"},
                {"name": "MAE", "value": mae, "valueType": "double"},
                {"name": "RMSE", "value": rmse, "valueType": "double"}]

    return metric

Beachten Sie, dass die Funktion ein metric-Objekt zurückgibt, das eine Gruppe von Bewertungsmetriken enthält. Anhand dieser Metriken lässt sich bewerten, wie gut das trainierte Modell funktioniert.

Data Saver-Datei

Die datasaver.py-Datei enthält die save()-Funktion zum Speichern Ihrer Prognose beim Testen des Scoring. The save() function will take your prediction and using Experience Platform Catalog APIs, write the data to the scoringResultsDataSetId you specified in your scoring.conf file.

Das Beispiel, das im Rezept für Einzelhandelsumsätze verwendet wird, ist hier dargestellt. Beachten Sie den Einsatz der DataSetWriter-Bibliothek zum Schreiben von Daten in Platform:

from data_access_sdk_python.writer import DataSetWriter

def save(configProperties, prediction):
    print("Datasaver Start")
    print("Setting up Writer")

    catalog_url = "https://platform.adobe.io/data/foundation/catalog"
    ingestion_url = "https://platform.adobe.io/data/foundation/import"

    writer = DataSetWriter(catalog_url=catalog_url,
                           ingestion_url=ingestion_url,
                           client_id=configProperties['ML_FRAMEWORK_IMS_USER_CLIENT_ID'],
                           user_token=configProperties['ML_FRAMEWORK_IMS_TOKEN'],
                           service_token=configProperties['ML_FRAMEWORK_IMS_ML_TOKEN'])

    print("Writer Configured")

    writer.write(data_set_id=configProperties['scoringResultsDataSetId'],
                 dataframe=prediction,
                 ims_org=configProperties['ML_FRAMEWORK_IMS_TENANT_ID'])

    print("Write Done")
    print("Datasaver Finish")
    print(prediction)

Training und Scoring

Wenn Sie die Änderungen an Ihrem Notebook abgeschlossen haben und Ihr Rezept trainieren möchten, können Sie oben in der Leiste auf die entsprechenden Schaltflächen klicken, um einen Trainings-Lauf in der Zelle zu erstellen. Nach dem Klicken auf die Schaltfläche wird ein Protokoll mit Befehlen und Ausgaben aus dem Trainings-Skript im Notebook angezeigt (unter der Zelle evaluator.py). Conda installiert zunächst alle Abhängigkeiten, dann wird das Training initiiert.

Beachten Sie, dass Sie ein Training mindestens einmal ausführen müssen, bevor Sie mit dem Scoring fortfahren können. Wenn Sie auf die Schaltfläche Scoring ausführen klicken, wird das trainierte Modell, das beim Trainieren erzeugt wurde, bewertet. Das Scoring-Skript wird unter datasaver.py angezeigt.

Wenn Sie zum Debuggen die ausgeblendete Ausgabe anzeigen möchten, fügen Sie debug am Ende der Ausgabenzelle hinzu und führen Sie das Scoring erneut aus.

Rezept erstellen

When you are done editing the recipe and satisfied with the training/scoring output, you can create a recipe from the notebook by pressing Create Recipe in the top-right navigation.

Nach dem Klicken auf die Schaltfläche werden Sie aufgefordert, einen Rezeptnamen einzugeben. Dieser Name stellt das eigentliche Rezept dar, das am Platform.

Wenn Sie auf OK klicken, können Sie in Adobe Experience Platform zum neuen Rezept navigieren. Sie können auf die Schaltfläche Rezepte anzeigen klicken, um zur Registerkarte Rezepte unter ML-Modelle zu gelangen.

Sobald der Prozess abgeschlossen ist, sieht das Rezept in etwa wie folgt aus:

VORSICHT
  • Löschen Sie keine der Dateizellen.
  • Bearbeiten Sie nicht die %%writefile-Zeile oben in den Dateizellen.
  • Erstellen Sie nicht gleichzeitig Rezepte in verschiedenen Notebooks.

Nächste Schritte

In diesem Tutorial haben Sie gelernt, wie Sie im Recipe Builder-Notebook ein Modell für maschinelles Lernen einrichten können. You have also learned how to exercise the notebook to recipe workflow within the notebook to create a recipe within Data Science Workspace.

To continue learning how to work with resources within Data Science Workspace, please visit the Data Science Workspace recipes and models dropdown.

Zusätzliche Ressourcen

Das folgende Video hilft Ihnen beim Einrichten und Bereitstellen von Modellen.

Auf dieser Seite