Prise en charge d'artefacts volumineux dans le catalogue de modèles

Étapes préliminaires de l'utilisation d'ADS

Tout d'abord, créez quelques méthodes d'utilitaire pour que l'exemple fonctionne :

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))

Ensuite, créez un exemple de modèle à utiliser dans cet exemple et alimentez le modèle avec un fichier CSV à grande échelle. Cet exemple utilise un fichier de 20 Mo pour un travail allant jusqu'à 6 Go.

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"))

Enregistrement d'un modèle volumineux dans le catalogue de modèles

Vous devez avoir un compartiment Object Storage pour prendre en charge les modèles dont la taille est supérieure à 2 Go. Vous pouvez créer un seau dans la console ou à l'aide de l'API OCI.

Créez un compartiment de stockage d'objets à partir de la console :

1. Connectez-vous à la console.
2. Ouvrez le menu de navigation et sélectionnez Stockage. Sous Stockage d'objets et stockage d'archives, sélectionnez Seaux.
3. Sous Portée de la liste, sélectionnez un compartiment.
4. Sélectionnez Créer un seau.

   Entrez les informations suivantes sur le formulaire Créer un seau.

   • Nom du seau : Entrez a-bucket-name.
   • Niveau de stockage par défaut : Sélectionnez Standard.

     Ne sélectionnez pas les options suivantes :

     • Activer la définition automatique de niveaux
     • Activer le contrôle des versions d'objet
     • Émettre des événements d'objet
     • Nettoyage des chargements en plusieurs parties non validés
   • Chiffrement : Sélectionnez Chiffrer à l'aide des clés gérées par Oracle
5. Sélectionnez Créer. Le seau est créé.

Construire l'URI du seau

L'URI du seau n'est pas répertorié dans la page des détails du seau de la console. Vous devez donc créer l'URI vous-même. Créez l'URI du seau :

1. Utilisez le modèle suivant pour créer l'URI de seau :

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

   Remplacez le nom du seau par celui que vous avez créé. Pour l'espace de noms, utilisez un nom de location (par exemple : my-tenancy). Pour le dossier d'objets, utilisez my-object-folder.

   Avec les données fournies, bucket_uri serait : oci://my-bucket-name@my-tenancy/my-object-folder/.

2. Pour charger des artefacts de modèle volumineux, vous devez ajouter deux paramètres supplémentaires à la méthode GenericModel.save(...) :
   • bucket_uri: (str, optional) est réglé par défaut à Aucun.

     URI du stockage d'objets vers lequel l'artefact de modèle est temporairement copié.

     bucket_uri n'est nécessaire que pour charger des artefacts volumineux dont la taille est supérieure à 2 Go. Cependant, vous pouvez également utiliser la méthode avec de petits artefacts. Par exemple :

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

   • remove_existing_artifact: (bool, optional) prend par défaut la valeur True.

     La méthode détermine si les artefacts chargés dans le seau de stockage d'objets doivent être supprimés.

3. Prenez l'artefact de modèle et copiez-le d'une session de carnet vers bucket_uri.
4. Ensuite, copiez l'artefact du seau (bucket_uri) vers le seau de service.

   Si la taille de l'artefact supérieure à 2 Go et bucket_uri n'est pas indiquée, une erreur se produit.

   Par défaut, l'attribut remove_existing_artifact est réglé à True. L'artefact est automatiquement supprimé du seau (bucket_uri) après un chargement réussi dans le seau de service. Si vous ne voulez pas supprimer l'artefact du seau, définissez : remove_existing_artifact = False.

En résumé, le traitement est le suivant :

1. Préparer les artefacts de modèle.
2. Enregistrez les informations de base sur le modèle dans le catalogue de modèles.
3. Chargez les artefacts de modèle dans un seau de stockage d'objets (bucket_uri).
4. Charger les artefacts de modèle d'un seau dans le seau de service de catalogue de modèles.
5. Supprimez les artefacts temporaires d'un seau en fonction du paramètre remove_existing_artifact :

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

Chargement d'un grand modèle dans le catalogue de modèles

Pour charger des modèles dont la taille est supérieure à 2 Go, ajoutez deux paramètres supplémentaires à la méthode GenericModel.from_model_catalog(...) :

• bucket_uri: (str, optional) est réglé par défaut à Aucun.

  URI de stockage d'objets vers lequel les artefacts de modèle sont temporairement copiés. bucket_uri n'est nécessaire que pour télécharger des artefacts volumineux dont la taille est supérieure à 2 Go. La méthode fonctionne également avec les petits artefacts. Exemple : oci://<bucket_name>@<namespace>/prefix/.

• remove_existing_artifact: (bool, optional) La valeur par défaut est 'Vrai'.

  La méthode détermine si les artefacts chargés dans le seau de stockage d'objets doivent être supprimés.

En résumé, le traitement est le suivant :

1. Téléchargez les artefacts de modèle à partir du seau de stockage d'objets du service de catalogue de modèles vers un seau.
2. Téléchargez les artefacts de modèle du seau vers la session de carnet.
3. Supprimez les artefacts temporaires du seau en fonction du paramètre remove_existing_artifact.

4. Chargez les informations de base sur le modèle à partir du catalogue de modèles :

   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
   )