AI Center
2023.4
False
Bannerhintergrundbild
AI Center – Benutzerhandbuch
Letzte Aktualisierung 28. Feb. 2024

Upload File

Erstellen von ML-Paketen

Die Data Scientists erstellen vortrainierte Modelle mit Python oder einer AutoML-Plattform. Diese Modelle werden von RPA-Entwicklern innerhalb eines Workflows verwendet.

ML-Pakete strukturieren

Ein Paket muss ein paar Voraussetzungen erfüllen. Diese Voraussetzungen werden in Komponenten unterteilt, die für die Ausgabe eines Modells erforderlich sind, und Komponenten, die für das Training eines Modells erforderlich sind.

Ausgebende Komponente

Ein Paket muss mindestens Folgendes enthalten:
  • Ein Ordner, der eine main.py-Datei im Stammverzeichnis dieses Ordners enthält.
  • In dieser Datei eine Klasse mit dem Namen Main, die mindestens zwei Funktionen implementiert:
    • __init__(self): Akzeptiert kein Argument und lädt Ihr Modell und/oder lokale Daten für das Modell (z. B. Worteinbettungen).
    • predict(self, input) : Eine Funktion, die zum Zeitpunkt der Modellbereitstellung aufgerufen wird und einen String zurückgibt.
  • Eine Datei mit dem Namen requirements.txt und mit Abhängigkeiten, die zum Ausführen des Modells erforderlich sind.
Stellen Sie sich die ausgebende Komponente eines Pakets als Modell zur Inferenzzeit vor. Bei der Ausgabe wird ein Container-Image mit der bereitgestellten requirements.txt-Datei erstellt und die Funktion predict wird als Endpunkt des Modells verwendet.

Trainings- und Auswertungskomponente

Zusätzlich zur Inferenz kann optional ein Paket zum Trainieren eines Machine Learning-Modells verwendet werden. Dies geschieht, indem Folgendes bereitgestellt wird:
  • Stellen Sie im gleichen Stammordner mit der main.py-Datei eine Datei mit dem Namen train.py bereit.
  • Geben Sie in dieser Datei eine Klasse mit dem Namen Main an, die mindestens vier Funktionen implementiert. Alle folgenden Funktionen mit Ausnahme von _init_ sind optional, beschränken jedoch den Typ der Pipelines, die mit dem entsprechenden Paket ausgeführt werden können.
    • __init__(self): Akzeptiert kein Argument und lädt Ihr Modell und/oder Daten für das Modell (z. B. Worteinbettungen).
    • train(self, training_directory): Nimmt als Eingabe ein Verzeichnis mit beliebig strukturierten Daten und führt den gesamten Code aus, der zum Trainieren eines Modells erforderlich ist. Diese Funktion wird aufgerufen, wenn eine Trainingspipeline ausgeführt wird.
    • evaluate(self, evaluation_directory): Nimmt als Eingabe ein Verzeichnis mit beliebig strukturierten Daten, führt den gesamten Code aus, der zum Auswerten eines Modus erforderlich ist, und gibt eine einzelne Punktzahl für diese Bewertung zurück. Diese Funktion wird aufgerufen, wenn eine Auswertungspipeline ausgeführt wird.
    • save(self): Akzeptiert kein Argument. Diese Funktion wird nach jedem Aufruf der train-Funktion aufgerufen, um Ihr Modell beizubehalten.
    • process_data(self, input_directory): Nimmt eine input_directory-Eingabe mit beliebig strukturierten Daten. Diese Funktion wird nur aufgerufen, wenn eine vollständige Pipeline ausgeführt wird. Bei der Ausführung einer vollständigen Pipeline kann diese Funktion beliebige Datentransformationen durchführen und Daten aufteilen. Insbesondere sind alle Daten, die in dem Pfad gespeichert werden, auf den die Umgebungsvariable training_data_directory verweist, die Eingabe der train-Funktion und alle Daten, die in dem Pfad gespeichert werden, auf den die Umgebungsvariable evaluation_data_directory verweist, sind die Eingabe der evaluation-Funktion oben.

Umgang mit Datentypen

Um die Nutzung von UiPath AI Center™ in einem RPA-Workflow einfacher zu gestalten, kann das Paket mit einem von drei Eingabetypen bezeichnet werden: String, Datei und Dateien (festgelegt beim Hochladen des Pakets).

String-Daten

Dies ist eine Abfolge von Zeichen. Alle Daten, die serialisiert werden können, können mit einem Paket verwendet werden. Wenn sie innerhalb eines RPA-Workflows verwendet werden, können die Daten vom Roboter serialisiert (z. B. mit einer benutzerdefinierten Aktivität) und als Zeichenfolge gesendet werden. Der Paket-Uploader muss JSON als Eingabetyp des Pakets ausgewählt haben.
Die Deserialisierung von Daten erfolgt in der Funktion predict. Im Folgenden finden Sie eine Handvoll Beispiele für die Deserialisierung von Daten in Python:
Robot sends raw string to ML Skill Activity
# E.g. skill_input='a customer complaint'`
def predict(self, skill_input):
  example = skill_input  # No extra processing
    
# Robot sends json formatted string to ML Skill Activity
# E.g skill_input='{'email': a customer complaint', 'date': 'mm:dd:yy'}'
def predict(self, skill_input):
  import json
  example = json.loads(skill_input)
  
# Robot sends json formatted string with number array to ML Skill Activity
# E.g. skill_input='[10, 15, 20]'
def predict(self, skill_input):
  import json
  import numpy as np
  example = np.array(json.loads(skill_input))
  
# Robot sends json formmatted pandas dataframe
# E.g. skill_input='{"row 1":{"col 1":"a","col 2":"b"},
#                    "row 2":{"col 1":"c","col 2":"d"}}'
def predict(self, skill_input):
  import pandas as pd
  example = pd.read_json(skill_input)Robot sends raw string to ML Skill Activity
# E.g. skill_input='a customer complaint'`
def predict(self, skill_input):
  example = skill_input  # No extra processing
    
# Robot sends json formatted string to ML Skill Activity
# E.g skill_input='{'email': a customer complaint', 'date': 'mm:dd:yy'}'
def predict(self, skill_input):
  import json
  example = json.loads(skill_input)
  
# Robot sends json formatted string with number array to ML Skill Activity
# E.g. skill_input='[10, 15, 20]'
def predict(self, skill_input):
  import json
  import numpy as np
  example = np.array(json.loads(skill_input))
  
# Robot sends json formmatted pandas dataframe
# E.g. skill_input='{"row 1":{"col 1":"a","col 2":"b"},
#                    "row 2":{"col 1":"c","col 2":"d"}}'
def predict(self, skill_input):
  import pandas as pd
  example = pd.read_json(skill_input)

Dateidaten

Dadurch wird der Aktivität ML Skill, die dieses Modell aufruft, mitgeteilt, einen Pfad zu einer Datei zu erwarten. Insbesondere liest die Aktivität die Datei aus dem Dateisystem und sendet sie an die predict-Funktion als serialisierte Bytezeichenfolge. So kann der RPA-Entwickler einen Pfad zu einer Datei übergeben, anstatt die Datei im Workflow selbst lesen und serialisieren zu müssen.
Innerhalb des Workflows ist die Eingabe der Aktivität nur der Pfad zur Datei. Die Aktivität liest die Datei, serialisiert sie und sendet die Dateibytes an die Funktion predict. Die Deserialisierung von Daten erfolgt auch in der Funktion predict, im Allgemeinen werden Bytes nur direkt in ein dateiähnliches Objekt gelesen, wie unten:
ML Package has been uploaded with *file* as input type. The ML Skill Activity
# expects a file path. Any file type can be passed as input and it will be serialized.
def predict(self, skill_input):
  import io
  file_like = io.BytesIO(skill_input)ML Package has been uploaded with *file* as input type. The ML Skill Activity
# expects a file path. Any file type can be passed as input and it will be serialized.
def predict(self, skill_input):
  import io
  file_like = io.BytesIO(skill_input)

Das Lesen der serialisierten Bytes wie oben entspricht dem Öffnen einer Datei mit aktiviertem Flag für binäres lesen. Um das Modell lokal zu testen, lesen Sie eine Datei als Binärdatei. Im folgenden Beispiel wird eine Bilddatei gelesen und lokal getestet:

main.py where model input is an image
class Main(object):
   ...
    
   def predict(self, skill_input): 
      import io
      from PIL import Image
      image = Image.open(io.BytesIO(skill_input))
   ...
  
if__name__ == '_main_':
   # Test the ML Package locally
   with open('./image-to-test-locally.png', 'rb') as input_file:
      file_bytes = input_file.read()
     m = Main()
     print(m.predict(file bytes))main.py where model input is an image
class Main(object):
   ...
    
   def predict(self, skill_input): 
      import io
      from PIL import Image
      image = Image.open(io.BytesIO(skill_input))
   ...
  
if__name__ == '_main_':
   # Test the ML Package locally
   with open('./image-to-test-locally.png', 'rb') as input_file:
      file_bytes = input_file.read()
     m = Main()
     print(m.predict(file bytes))
Das folgende Beispiel zeigt das Lesen einer csv-Datei und die Verwendung eines pandas Dataframe in der Funktion predict:
main.py where model input is a csv file
class Main(object):
   ...
   def predict(self, skill_input): 
      import pandas as pd
      data frame = pd.read_csv(io.BytesIO(skill_input))
      ...
      
if name == '_main_':
   # Test the ML Package locally
   with open('./csv—to—test—locally.csv', 'rb') as input_file:
      bytes = input_file.read()
   m = Main()
   print(m.predict(bytes))main.py where model input is a csv file
class Main(object):
   ...
   def predict(self, skill_input): 
      import pandas as pd
      data frame = pd.read_csv(io.BytesIO(skill_input))
      ...
      
if name == '_main_':
   # Test the ML Package locally
   with open('./csv—to—test—locally.csv', 'rb') as input_file:
      bytes = input_file.read()
   m = Main()
   print(m.predict(bytes))

Dateidaten

Dadurch wird das AI Center darüber informiert, dass die Aktivität ML Skill, die dieses Modell aufruft, eine Liste von Dateipfaden erwartet. Wie im vorherigen Fall liest und serialisiert die Aktivität jede Datei und sendet eine Liste von Byte-Strings an die Funktion predict.

Eine Liste von Dateien kann an eine Fähigkeit gesendet werden. Innerhalb des Workflows ist die Eingabe der Aktivität eine Zeichenfolge mit Pfaden zu den Dateien, die durch ein Komma getrennt sind.

Beim Hochladen eines Pakets wählt der Datenspezialist eine Liste von Dateien als Eingabetyp aus. Der Datenspezialist muss dann jede der gesendeten Dateien deserialisieren (wie oben erläutert). In die Funktion predict wird eine Liste von Bytes eingegeben, bei denen jedes Element in der Liste die Bytezeichenfolge der Datei ist.

Beibehalten beliebiger Daten

In train.py kann jede ausgeführte Pipeline beliebige Daten beibehalten, die als Pipelineausgabe bezeichnet werden. Alle Daten, die aus den Artefakten der Umgebungsvariablen in den Verzeichnispfad geschrieben werden, werden beibehalten und können jederzeit angezeigt werden, indem Sie zur Seite Pipelinedetails navigieren. In der Regel kann jede Art von Diagrammen und Statistiken der Trainings-/Auswertungsaufträge im artifacts-Verzeichnis gespeichert werden und am Ende der Pipelineausführung über die Benutzeroberfläche aufgerufen werden.
train.py where some historical plot are saved in ./artifacts directory during Full Pipeline execution
# Full pipeline (using process_data) will automatically split data.csv in 2/3 train.csv (which will be in the directory passed to the train function) and 1/3 test.csv
import pandas as pd
from sklearn.model_selection import train_test_split
class Main(object):
   ...
   def process_data(self, data_directory):
     d = pd.read_csv(os.path.join(data_directory, 'data.csv')) 
     d = self.clean_data(d)
     d_train, d_test = train_test_split(d, test_size=0.33, random_state=42)
     d_train.to_csv(os.path.join(data_directory , 'training', 'train.csv'), index=False)
     d_test.to_csv (os.path.join(data__directory , 'test' , 'test.csv'), index=False)
     self.save_artifacts(d_train, 'train_hist.png', os.environ["artifacts"])
     self.save_artifacts(d_test, 'test_hist.png', os.environ["artifacts"])
  ...
  
   def save_artifacts(self, data, file_name, artifact_directory):
      plot = data.hist() 
      fig = plot[0][0].get_figure()
      fig.savefig(os.path.join(artifact_directory, file_name))
...train.py where some historical plot are saved in ./artifacts directory during Full Pipeline execution
# Full pipeline (using process_data) will automatically split data.csv in 2/3 train.csv (which will be in the directory passed to the train function) and 1/3 test.csv
import pandas as pd
from sklearn.model_selection import train_test_split
class Main(object):
   ...
   def process_data(self, data_directory):
     d = pd.read_csv(os.path.join(data_directory, 'data.csv')) 
     d = self.clean_data(d)
     d_train, d_test = train_test_split(d, test_size=0.33, random_state=42)
     d_train.to_csv(os.path.join(data_directory , 'training', 'train.csv'), index=False)
     d_test.to_csv (os.path.join(data__directory , 'test' , 'test.csv'), index=False)
     self.save_artifacts(d_train, 'train_hist.png', os.environ["artifacts"])
     self.save_artifacts(d_test, 'test_hist.png', os.environ["artifacts"])
  ...
  
   def save_artifacts(self, data, file_name, artifact_directory):
      plot = data.hist() 
      fig = plot[0][0].get_figure()
      fig.savefig(os.path.join(artifact_directory, file_name))
...

Verwenden von TensorFlow

Während der Modellentwicklung muss das TensorFlow-Diagramm in denselben Thread geladen werden, der auch zur Ausgabe verwendet wird. Dazu muss das Standarddiagramm verwendet werden.

Im Folgenden finden Sie ein Beispiel mit den erforderlichen Änderungen:

import tensorflow as tf
class Main(object):
  def __init__(self):
    self.graph = tf.get_default_graph() # Add this line
    ...
    
  def predict(self, skill_input):
    with self.graph.as_default():
      ...import tensorflow as tf
class Main(object):
  def __init__(self):
    self.graph = tf.get_default_graph() # Add this line
    ...
    
  def predict(self, skill_input):
    with self.graph.as_default():
      ...

Informationen zur GPU-Nutzung

Wenn die GPU bei der Erstellung von Fähigkeiten aktiviert ist, wird sie auf einem Image mit NVIDIA GPU-Treiber 418, CUDA Toolkit 10.0 und der Laufzeitbibliothek CUDA Deep Neural Network Library (cuDNN) 7.6.5 bereitgestellt.

Beispiele

Einfaches Ready-to-Serve-ML-Modell ohne Training

In diesem Beispiel erfordert das Geschäftsproblem kein erneutes Training des Modells, daher muss das Paket das serialisierte Modell IrisClassifier.sav enthalten, das zur Verfügung gestellt wird.
  1. Anfängliche Projektstruktur (ohne main.py und requirements.txt):
    IrisClassifier/
      - IrisClassifier.savIrisClassifier/
      - IrisClassifier.sav
  2. Beispielhafte main.py, die dem Stammordner hinzugefügt werden soll:
    from sklearn.externals import joblib 
    import json
    class Main(object):
       def __init__(self):
          self.model = joblib.load('IrisClassifier.sav')
       def predict(self, X):
          X = json.loads(X)
          result = self.model.predict_proba(X)
          return json.dumps(result.tolist())from sklearn.externals import joblib 
    import json
    class Main(object):
       def __init__(self):
          self.model = joblib.load('IrisClassifier.sav')
       def predict(self, X):
          X = json.loads(X)
          result = self.model.predict_proba(X)
          return json.dumps(result.tolist())
  3. requirements.txt hinzufügen:
    scikit-learn==0.19.0scikit-learn==0.19.0
Hinweis: Bei pip-Bibliotheken müssen einige Einschränkungen beachtet werden. Stellen Sie sicher, dass Sie Bibliotheken unter den folgenden Einschränkungsdateien installieren können:
itsdangerous<2.1.0
Jinja2<3.0.5
Werkzeug<2.1.0
click<8.0.0itsdangerous<2.1.0
Jinja2<3.0.5
Werkzeug<2.1.0
click<8.0.0

Um dies zu testen, können Sie den folgenden Befehl in einer neuen Umgebung verwenden und sicherstellen, dass alle Bibliotheken ordnungsgemäß installiert werden:

pip install -r requirements.txt -c constraints.txtpip install -r requirements.txt -c constraints.txt

4. Endgültige Ordnerstruktur:

IrisClassifier/
  - IrisClassifier.sav
  - main.py
  - requirements.txtIrisClassifier/
  - IrisClassifier.sav
  - main.py
  - requirements.txt

Einfaches Ready-to-Serve-Modell mit aktiviertem Training

In diesem Beispiel erfordert das Geschäftsproblem, dass das Modell neu trainiert wird. Aufbauend auf dem oben beschriebenen Paket haben Sie möglicherweise Folgendes:

  1. Anfängliche Projektstruktur (Paket ,das nur ausgibt):
    IrisClassifier/
      - IrisClassifier.sav
      - main.py
      - requirements.txtIrisClassifier/
      - IrisClassifier.sav
      - main.py
      - requirements.txt
  2. Beispielcode für train.py, der dem Stammordner hinzugefügt werden sollte:
    import pandas as pd 
    import joblib
    class Main(object): 
       def __init__(self):
           self.model_path = './IrisClassifier.sav' 
           self.model = joblib.load(self.model_path)
          
       def train(self, training_directory):
           (X,y) = self.load_data(os.path.join(training_directory, 'train.csv'))
           self.model.fit(X,y)
       def evaluate(self, evaluation_directory):
           (X,y) = self.load_data(os.path.join(evaluation_directory, 'evaluate.csv'))
           return self.model.score(X,y)
       def save(self):
           joblib.dump(self.model, self.model_path)
       def load_data(self, path):
           # The last column in csv file is the target column for prediction.
           df = pd.read_csv(path)
           X = df.iloc[:, :-1].get_values()
           y = df.iloc[:, 'y'].get_values()
           return X,yimport pandas as pd 
    import joblib
    class Main(object): 
       def __init__(self):
           self.model_path = './IrisClassifier.sav' 
           self.model = joblib.load(self.model_path)
          
       def train(self, training_directory):
           (X,y) = self.load_data(os.path.join(training_directory, 'train.csv'))
           self.model.fit(X,y)
       def evaluate(self, evaluation_directory):
           (X,y) = self.load_data(os.path.join(evaluation_directory, 'evaluate.csv'))
           return self.model.score(X,y)
       def save(self):
           joblib.dump(self.model, self.model_path)
       def load_data(self, path):
           # The last column in csv file is the target column for prediction.
           df = pd.read_csv(path)
           X = df.iloc[:, :-1].get_values()
           y = df.iloc[:, 'y'].get_values()
           return X,y
  3. Bearbeiten Sie requirements.txt, falls erforderlich:
    pandas==1.0.1
    scikit-learn==0.19.0pandas==1.0.1
    scikit-learn==0.19.0
  4. Endgültige Ordnerstruktur (Paket):
    IrisClassifier/
      - IrisClassifier.sav
      - main.py
      - requirements.txt
      - train.pyIrisClassifier/
      - IrisClassifier.sav
      - main.py
      - requirements.txt
      - train.py
    Hinweis: Dieses Modell kann jetzt zuerst bereitgestellt werden, und da neue Datenpunkte über den Roboter oder Human-in-the-Loop in das System kommen, können Trainings- und Auswertungspipelines erstellt werden, die train.py nutzen.

ZIP-Datei hochladen

Wichtig:

Bevor Sie Pakete hochladen, stellen Sie sicher, dass diese wie hier angegeben erstellt wurden.

Beim Erstellen eines DU ML-Pakets im AI Center™ darf der Paketname kein reserviertes Python-Schlüsselwort enthalten, z. B. class, break, from, finally, global, None usw. Wählen Sie einen anderen Namen aus. Die aufgeführten Beispiele sind nicht vollständig, da der Paketname für class <pkg-name> und import <pck-name> verwendet wird.

Führen Sie die folgenden Schritte aus, um ein bereits erstelltes Paket hochzuladen:

  1. Klicken Sie auf der Seite ML-Pakete auf die Schaltfläche ZIP-Datei Hochladen. Die Seite Neues Paket erstellen wird angezeigt.
  2. Geben Sie auf der Seite Neues Paket erstellen einen Namen für Ihr Paket ein.
  3. Klicken Sie auf Paket hochladen, um die gewünschte .zip-Datei auszuwählen, oder ziehen Sie die .zip-Paketdatei per Drag and Drop in das Feld Paket hochladen.
  4. (Optional) Geben Sie eine eindeutige Beschreibung des Modells an.

    Die Beschreibung wird angezeigt, während eine neue Fähigkeit basierend auf diesem Modell sowie auf der Seite ML-Pakete bereitgestellt wird.

  5. Wählen Sie den Eingabetyp aus der Dropdownliste aus. Folgende Optionen stehen zur Auswahl:
    • json
    • Datei
    • Dateien
  6. Optional: Geben Sie eine eindeutige Beschreibung der vom Modell erwarteten Eingabe ein.
  7. Optional: Geben Sie eine eindeutige Beschreibung der vom Modell zurückgegebenen Ausgabe ein.
    Diese Beschreibungen sind für RPA-Entwickler sichtbar, die die Aktivität „ML-Fähigkeit“ in UiPath Studio verwenden. Als bewährte Vorgehensweise empfehlen wir, ein Beispiel für die Eingabe- und Ausgabeformate zu zeigen, um die Kommunikation zwischen Datenspezialisten und Entwicklern zu erleichtern.
  8. Wählen Sie die Entwicklungssprache des Modells aus der Dropdownliste aus. Folgende Optionen stehen zur Auswahl:
    • Python 3.7
    • Python 3.8
    • Python 3.8 OpenCV
  9. Wählen Sie aus, ob das Machine Learning-Modell eine GPU benötigt oder nicht; standardmäßig ist dies auf „Nein“ festgelegt. Diese Informationen werden als Vorschlag dafür angezeigt, wann eine Fähigkeit aus diesem Paket erstellt wird.
  10. Wählen Sie aus, ob Trainings für Ihr Modell aktiviert werden sollen. Dies passiert, wenn sie aktiviert sind:
    • Das Paket kann in jeder Pipeline verwendet werden.
    • Der Validierungsschritt prüft, ob die train.py-Datei im Paket implementiert ist, andernfalls schlägt die Validierung fehl.


  11. Klicken Sie auf Erstellen, um das Paket hochzuladen, oder auf Abbrechen, um den Prozess abzubrechen. Das Fenster Neues Paket erstellen wird geschlossen, das Paket wird hochgeladen und zusammen mit seinen Details auf der Seite ML-Pakete > [ML-Paketname] angezeigt. Es kann einige Minuten dauern, bis Ihr Upload weitergegeben wird.


War diese Seite hilfreich?

Hilfe erhalten
RPA lernen – Automatisierungskurse
UiPath Community-Forum
UiPath Logo weiß
Vertrauen und Sicherheit
© 2005-2024 UiPath. All rights reserved.