Soporte de artefactos grandes en el catálogo de modelos

Pasos preliminares para el uso de ADS

En primer lugar, cree algunos métodos de utilidad para que el ejemplo funcione:

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

A continuación, cree un modelo de ejemplo para utilizarlo en este ejemplo y rellene el modelo con un archivo CSV a gran escala. En este ejemplo se utiliza un archivo de 20 MB, aunque los archivos de hasta 6 GB funcionan.

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

Almacenamiento de un modelo grande en el catálogo de modelos

Debe tener un cubo de Object Storage para soportar modelos de más de 2 GB. Puede crear un cubo en la consola o mediante la API de OCI.

Cree un cubo de Object Storage desde la consola:

1. Conéctese a la consola.
2. Abra el menú de navegación y seleccione Storage. En Object Storage & Archive Storage, seleccione Buckets.
3. En Ámbito de lista, seleccione un compartimento.
4. Seleccione Crear cubo.

   Introduzca la siguiente información de formulario en el formulario Crear cubo.

   • Nombre de cubo: introduzca un nombre de cubo.
   • Default Storage Tier: seleccione Standard.

     No seleccione las siguientes opciones:

     • Activar organización automática en niveles
     • Activar control de versiones de objeto
     • Emitir eventos de objeto
     • Limpieza de cargas de varias partes sin confirmar
   • Cifrado: seleccione Cifrado con claves gestionadas por Oracle
5. Haga clic en Crear. Se crea el cubo.

Crear el URI de cubo

El URI de cubo no aparece en la página de detalles de cubo de la consola, por lo que debe crear el URI usted mismo. Cree el URI de cubo:

1. Utilice la siguiente plantilla para crear el URI de cubo:

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

   Sustituya el nombre del cubo por el que ha creado. Para el espacio de nombres, utilice un nombre de arrendamiento (por ejemplo: my-tenancy). Para la carpeta de objetos, utilice my-object-folder.

   Con los datos proporcionados, bucket_uri sería: oci://my-bucket-name@my-tenancy/my-object-folder/.

2. Para cargar artefactos de modelo de gran tamaño, debe agregar dos parámetros adicionales al método GenericModel.save(...):
   • bucket_uri: (str, optional) El valor por defecto es Ninguno.

     URI de Object Storage en el que se copia temporalmente el artefacto del modelo.

     bucket_uri solo es necesario para cargar artefactos grandes cuando el tamaño es superior a 2 GB. Sin embargo, también puede utilizar el método con artefactos pequeños. Por ejemplo:

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

   • remove_existing_artifact: (bool, optional) El valor por defecto es True.

     El método decide si se deben eliminar los artefactos cargados en el cubo de Object Storage.

3. Tome el artefacto del modelo y cópielo de una sesión de bloc de notas en bucket_uri.
4. A continuación, copie el artefacto del cubo (bucket_uri) en el cubo de servicio.

   Si no se proporciona un tamaño de artefacto superior a 2 GB y bucket_uri, se produce un error.

   Por defecto, el atributo remove_existing_artifact está definido en True. El artefacto se elimina automáticamente del cubo (bucket_uri) después de una carga correcta en el cubo de servicio. Si no desea eliminar el artefacto del cubo, defina: remove_existing_artifact = False.

En resumen, el proceso es:

1. Prepare los artefactos del modelo.
2. Guardar información base sobre el modelo en el catálogo de modelos.
3. Cargue artefactos de modelo en un cubo de Object Storage (bucket_uri).
4. Cargue artefactos de modelo de un cubo en el cubo del servicio de catálogo de modelos.
5. Elimine los artefactos temporales de un cubo según el parámetro remove_existing_artifact:
   Copiar

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

Carga de un modelo grande en el catálogo de modelos

Para cargar modelos de más de 2 GB, agregue dos parámetros adicionales al método GenericModel.from_model_catalog(...):

• bucket_uri: (str, optional) El valor por defecto es Ninguno.

  URI de Object Storage en el que se copian temporalmente artefactos de modelo. bucket_uri solo es necesario para descargar artefactos grandes de un tamaño superior a 2 GB. El método también funciona con los pequeños artefactos. Ejemplo: oci://<bucket_name>@<namespace>/prefix/.

• remove_existing_artifact: (bool, optional) El valor por defecto es "Verdadero".

  El método decide si se deben eliminar los artefactos cargados en el cubo de Object Storage.

En resumen, el proceso es:

1. Descargue los artefactos de modelo del cubo de Object Storage del servicio de catálogo de modelos en un cubo.
2. Descargue los artefactos de modelo del cubo a la sesión de bloc de notas.
3. Elimine los artefactos temporales del cubo según el parámetro remove_existing_artifact.

4. Cargue la información base sobre el modelo del catálogo de modelos:

   Copiar

   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
   )