Große Artefakte im Modellkatalog unterstützen

Vorläufige Schritte zur Verwendung von ADS

Erstellen Sie zunächst einige Utility-Methoden für das Beispiel:

import os
import oci
import random
import warnings
import numpy as np

import ads
from ads.catalog.model import ModelCatalog
from ads.common.model_metadata import UseCaseType
from ads.model.generic_model import GenericModel

from numpy import array
from numpy import ndarray
from shutil import rmtree

ads.set_auth("resource_principal")
warnings.filterwarnings('ignore')

# ads.set_auth("api_key")
# ads.set_debug_mode(False)
# auth = {"config": oci.config.from_file(os.path.join("~/.oci", "config"))}

from sklearn.datasets import make_classification
import pandas as pd
import os

class Size:
    MB_20 = 6000
    MB_200 = 60000
    MB_2000 = 600000    

def generate_large_csv(size: Size = Size.MB_20, file_path: str = "./large_csv_file.csv"):
    X_big, y_big = make_classification(n_samples=size, n_features=200)
    df_big = pd.concat([pd.DataFrame(X_big), pd.DataFrame(y_big)], axis=0)
    df_big.to_csv(os.path.join(file_path))

Erstellen Sie als Nächstes ein Beispielmodell, das in diesem Beispiel verwendet werden soll, und füllen Sie das Modell mit einer groß angelegten CSV-Datei auf. In diesem Beispiel wird eine Datei mit 20 MB verwendet, obwohl Dateien mit bis zu 6 GB funktionieren.

class Square:
    def predict(self, x):
        x_array = np.array(x)
        return np.ndarray.tolist(x_array * x_array)
    
model = Square()


artifact_dir = "./large_artifact/"

generic_model = GenericModel(
    estimator=model, 
    artifact_dir=artifact_dir
)
generic_model.prepare(
    inference_conda_env="dataexpl_p37_cpu_v3",
    training_conda_env="dataexpl_p37_cpu_v3",
    use_case_type=UseCaseType.MULTINOMIAL_CLASSIFICATION,

    X_sample=X,
    y_sample=array(X) ** 2,
    force_overwrite=True
)

generate_large_csv(Size.MB_20, file_path=os.path.join(artifact_dir, "large_csv_file.csv"))

Großes Modell speichern

Sie benötigen einen Objektspeicher-Bucket, um Modelle mit mehr als 2 GB zu unterstützen. Sie können einen Bucket in der Konsole oder mit der OCI-API erstellen.

Erstellen Sie einen Object Storage-Bucket über die Konsole:

1. Melden Sie sich bei der Konsole an.
2. Öffnen Sie das Navigationsmenü, und wählen Sie Speicher aus. Wählen Sie unter Object Storage und Archive Storage die Option Buckets aus.
3. Wählen Sie unter Listenbereich ein Compartment aus.
4. Wählen Sie Bucket erstellen aus.

   Geben Sie die folgenden Formularinformationen in das Formular Bucket erstellen ein.

   • Gruppenname: Geben Sie "a-bucket-name" ein.
   • Standard-Storage-Tier: Wählen Sie Standard aus.

     Wählen Sie die folgenden Optionen nicht aus:

     • Auto-Tiering aktivieren
     • Objektversionierung aktivieren
     • Objektereignisse ausgeben
     • Bereinigung nicht festgeschriebener Multipart-Uploads
   • Verschlüsselung: Wählen Sie Mit von Oracle verwalteten Schlüsseln verschlüsseln aus.
5. Wählen Sie Erstellen. Der Bucket wird erstellt.

Bucket-URI erstellen

Die Bucket-URI ist nicht auf der Seite mit den Bucket-Details in der Konsole aufgeführt. Sie müssen daher die URI selbst erstellen. Erstellen Sie die Bucket-URI:

1. Verwenden Sie die folgende Vorlage, um die Bucket-URI zu erstellen:

   oci://<bucket_name>@<namespace>/<objects_folder>/.

   Ersetzen Sie den Bucket-Namen durch den Namen, den Sie erstellt haben. Verwenden Sie für Namespace einen Mandantennamen (Beispiel: my-tenancy). Verwenden Sie für den Objektordner my-object-folder.

   Mit den angegebenen Daten wäre bucket_uri: oci://my-bucket-name@my-tenancy/my-object-folder/.

2. Um große Modellartefakte hochzuladen, müssen Sie der Methode GenericModel.save(...) zwei zusätzliche Parameter hinzufügen:
   • bucket_uri: (str, optional) ist standardmäßig "Keine".

     Die Object Storage-URI, in die das Modellartefakt vorübergehend kopiert wird.

     Die bucket_uri ist nur für das Hochladen großer Artefakte erforderlich, wenn die Größe größer als 2 GB ist. Sie können die Methode jedoch auch mit kleinen Artefakten verwenden. Beispiel:

     oci://<bucket_name>@<namespace>/prefix/.

   • remove_existing_artifact: (bool, optional) ist standardmäßig True.

     Die Methode bestimmt, ob Artefakte, die in den Objektspeicher-Bucket hochgeladen wurden, entfernt werden sollen.

3. Nehmen Sie das Modellartefakt, und kopieren Sie es aus einer Notizbuchsession in bucket_uri.
4. Kopieren Sie als Nächstes das Artefakt aus dem Bucket (bucket_uri) in den Service-Bucket.

   Wenn die Artefaktgröße größer als 2 GB und bucket_uri nicht angegeben ist, tritt ein Fehler auf.

   Standardmäßig ist das Attribut remove_existing_artifact auf True gesetzt. Das Artefakt wird nach einem erfolgreichen Upload in den Service-Bucket automatisch aus dem Bucket (bucket_uri) entfernt. Wenn Sie das Artefakt nicht aus dem Bucket entfernen möchten, legen Sie Folgendes fest: remove_existing_artifact = False.

Zusammenfassend lässt sich sagen, dass der Prozess wie folgt abläuft:

1. Modellartefakte vorbereiten
2. Speichern Sie Basisinformationen zum Modell im Modellkatalog.
3. Modellartefakte in einen Objektspeicher-Bucket hochladen (bucket_uri).
4. Modellartefakte aus einem Bucket in den Modellkatalogservice-Bucket hochladen.
5. Temporäre Artefakte aus einem Bucket basierend auf dem Parameter remove_existing_artifact entfernen:

   large_model_id = generic_model.save(
       display_name='Generic Model With Large Artifact',
       bucket_uri=<provide bucket uri>,
       remove_existing_artifact=True
   )

Large Model in den Modellkatalog laden

Um Modelle mit mehr als 2 GB zu laden, fügen Sie der Methode GenericModel.from_model_catalog(...) zwei zusätzliche Parameter hinzu:

• bucket_uri: (str, optional) ist standardmäßig "Keine".

  Die Object Storage-URI, in die Modellartefakte vorübergehend kopiert werden. Die bucket_uri ist nur zum Herunterladen großer Artefakte erforderlich, die eine Größe von mehr als 2 GB aufweisen. Die Methode funktioniert auch mit den kleinen Artefakten. Beispiel: oci://<bucket_name>@<namespace>/prefix/.

• remove_existing_artifact: (bool, optional) Der Standardwert ist "True".

  Die Methode bestimmt, ob Artefakte, die in den Objektspeicher-Bucket hochgeladen wurden, entfernt werden sollen.

Zusammenfassend lässt sich sagen, dass der Prozess wie folgt abläuft:

1. Laden Sie die Modellartefakte aus dem Objektspeicher-Bucket des Modellkatalogservice in einen Bucket herunter.
2. Laden Sie die Modellartefakte aus dem Bucket in die Notizbuchsession herunter.
3. Entfernen Sie die temporären Artefakte basierend auf dem Parameter remove_existing_artifact aus dem Bucket.

4. Laden Sie die Basisinformationen zum Modell aus dem Modellkatalog:

   large_model = GenericModel.from_model_catalog(
       large_model_id,
       "model.pkl",
       "./downloaded_large_artifact/",
       bucket_uri=<provide bucket uri> ,
       force_overwrite=True,
       remove_existing_artifact=True
   )