Supporto di artifact di grandi dimensioni nel catalogo modelli

Passi preliminari per l'utilizzo di ADS

In primo luogo, creare alcuni metodi di utilità per l'esempio da utilizzare:

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

Successivamente, creare un modello di esempio da utilizzare in questo esempio e inserire un file CSV su larga scala nel modello. Questo esempio utilizza un file da 20 MB con file fino a 6 GB di lavoro.

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

Salvataggio di un modello di grandi dimensioni nel catalogo modelli

Per supportare modelli con dimensioni superiori a 2 GB, è necessario disporre di un bucket di storage degli oggetti. Puoi creare un bucket nella console o utilizzando l'API OCI.

Creare un bucket di storage degli oggetti dalla console:

1. Accedi alla console.
2. Aprire il menu di navigazione e selezionare Memorizzazione. In Storage degli oggetti e storage di archivio selezionare Bucket.
3. In Ambito elenco, selezionare un compartimento.
4. Selezionare Crea bucket.

   Immettere le seguenti informazioni nel form Crea bucket.

   • Nome gruppo: immettere a-bucket-name.
   • Livello di storage predefinito: selezionare Standard.

     Non selezionare le opzioni seguenti.

     • Abilita gestione automatica dei livelli
     • Abilita controllo delle versioni oggetto
     • Emetti eventi oggetto
     • Cleanup caricamenti multiparte senza commit
   • Cifratura: selezionare Cifra mediante chiavi gestite da Oracle
5. Selezionare Crea. Il bucket viene creato.

Costruisce l'URI bucket

L'URI bucket non è elencato nella pagina dei dettagli del bucket nella console, pertanto è necessario creare l'URI manualmente. Creare l'URI del bucket:

1. Utilizzare il modello riportato di seguito per creare l'URI del bucket:

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

   Sostituire il nome del bucket con quello creato. Per lo spazio di nomi, utilizzare un nome di tenancy (ad esempio: my-tenancy). Per la cartella degli oggetti, utilizzare my-object-folder.

   Con i dati forniti, il bucket_uri sarebbe: oci://my-bucket-name@my-tenancy/my-object-folder/.

2. Per caricare artifact di modelli di grandi dimensioni, è necessario aggiungere due parametri aggiuntivi al metodo GenericModel.save(...):
   • bucket_uri: (str, optional) Il valore predefinito è Nessuno.

     URI di storage degli oggetti in cui viene copiato temporaneamente l'artifact del modello.

     bucket_uri è necessario solo per il caricamento di artifact di grandi dimensioni quando la dimensione è maggiore di 2 GB. Tuttavia, è anche possibile utilizzare il metodo con piccoli artefatti. Ad esempio:

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

   • remove_existing_artifact: (bool, optional) Il valore predefinito è True.

     Il metodo decide se gli artifact caricati nel bucket di storage degli oggetti devono essere rimossi.

3. Prendere l'artifact del modello e copiarlo da una sessione notebook a bucket_uri.
4. Successivamente, copiare l'artifact dal bucket (bucket_uri) nel bucket del servizio.

   Se la dimensione dell'artifact maggiore di 2 GB e bucket_uri non viene fornita, si verifica un errore.

   Per impostazione predefinita, l'attributo remove_existing_artifact è impostato su True. L'artifact viene rimosso automaticamente dal bucket (bucket_uri) dopo un caricamento riuscito nel bucket del servizio. Se non si desidera rimuovere l'artifact dal bucket, impostare: remove_existing_artifact = False.

Per riassumere, il processo è:

1. Preparare gli artifact del modello.
2. Salvare le informazioni di base sul modello nel catalogo modelli.
3. Caricare gli artifact del modello in un bucket di storage degli oggetti (bucket_uri).
4. Caricare gli artifact del modello da un bucket nel bucket del servizio del catalogo modelli.
5. Rimuovere gli artifact temporanei da un bucket in base al parametro 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
   )

Caricamento di un modello di grandi dimensioni nel catalogo modelli

Per caricare modelli con dimensioni superiori a 2 GB, aggiungere due parametri aggiuntivi al metodo GenericModel.from_model_catalog(...):

• bucket_uri: (str, optional) Il valore predefinito è Nessuno.

  URI di storage degli oggetti in cui vengono copiati temporaneamente gli artifact del modello. bucket_uri è necessario solo per scaricare artifact di grandi dimensioni di dimensioni superiori a 2 GB. Il metodo funziona anche con i piccoli artefatti. Esempio: oci://<bucket_name>@<namespace>/prefix/.

• remove_existing_artifact: (bool, optional) L'impostazione predefinita è `True`.

  Il metodo decide se gli artifact caricati nel bucket di storage degli oggetti devono essere rimossi.

Per riassumere, il processo è:

1. Scaricare gli artifact del modello dal bucket di storage degli oggetti del servizio catalogo modelli in un bucket.
2. Scaricare gli artifact del modello dal bucket alla sessione notebook.
3. Rimuovere gli artifact temporanei dal bucket in base al parametro remove_existing_artifact.

4. Caricare le informazioni di base sul modello dal catalogo modelli:

   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
   )