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

Etapes préliminaires d'utilisation d'ADS

Commencez par créer des méthodes utilitaires 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 remplissez le modèle avec un fichier CSV à grande échelle. Cet exemple utilise un fichier de 20 Mo avec des fichiers 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 grand modèle dans le catalogue de modèles

Vous devez disposer d'un bucket Object Storage pour prendre en charge les modèles de plus de 2 Go. Vous pouvez créer un bucket dans la console ou à l'aide de l'API OCI.

Créez un bucket Object Storage à partir de la console :

1. Connectez-vous à la console.
2. Ouvrez le menu de navigation et sélectionnez Stockage. Sous Object Storage et Archive Storage, sélectionnez Buckets.
3. Sous Portée de la liste, sélectionnez un compartiment.
4. Sélectionnez Créer un bucket.

   Entrez les informations de formulaire suivantes dans le formulaire Créer un bucket.

   • Nom de la catégorie : entrez a-bucket-name.
   • Niveau de stockage par défaut : sélectionnez Standard.

     Ne sélectionnez pas les options suivantes :

     • Activer la gestion des niveaux automatique
     • Activer la gestion des versions d'objet
     • Emission d'événements d'objet
     • Nettoyage des téléchargements multipart non validés
   • Cryptage : sélectionnez Crypter à l'aide des clés gérées par Oracle.
5. Choisissez Créer. Le bucket est créé.

Construire l'URI de bucket

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

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

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

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

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

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

     URI Object Storage vers lequel l'artefact de modèle est temporairement copié.

     bucket_uri est uniquement nécessaire pour télécharger des artefacts volumineux lorsque 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) La valeur par défaut est True.

     La méthode détermine si les artefacts téléchargés vers le bucket Object Storage doivent être enlevés.

3. Prenez l'artefact de modèle et copiez-le à partir d'une session de bloc-notes vers bucket_uri.
4. Copiez ensuite l'artefact du bucket (bucket_uri) vers le bucket de service.

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

   Par défaut, l'attribut remove_existing_artifact est défini sur True. L'artefact est automatiquement enlevé du bucket (bucket_uri) après un téléchargement vers le bucket de service. Si vous ne voulez pas enlever l'artefact du bucket, définissez remove_existing_artifact = False.

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

1. Préparez les artefacts de modèle.
2. Enregistrez les informations de base sur le modèle dans le catalogue de modèles.
3. Téléchargez des artefacts de modèle vers un bucket Object Storage (bucket_uri).
4. Téléchargez des artefacts de modèle à partir d'un bucket vers le bucket de service de catalogue de modèles.
5. Enlevez les artefacts temporaires d'un bucket 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
   )

Charger un modèle volumineux dans le catalogue de modèles

Pour charger des modèles de plus de 2 Go, ajoutez deux paramètres supplémentaires à la méthode GenericModel.from_model_catalog(...) :

• bucket_uri: (str, optional) La valeur par défaut est Aucun.

  URI Object Storage vers lequel les artefacts de modèle sont temporairement copiés. bucket_uri est uniquement nécessaire 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 "True".

  La méthode détermine si les artefacts téléchargés vers le bucket Object Storage doivent être enlevés.

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

1. Téléchargez les artefacts de modèle du bucket Object Storage du service de catalogue de modèles vers un bucket.
2. Téléchargez les artefacts de modèle du bucket vers la session de bloc-notes.
3. Enlevez les artefacts temporaires du bucket 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
   )