Esta página ha sido traducida por una máquina.

Documentación de Oracle Cloud Infrastructure
Probar cuenta gratuita

Creación y guardado de un modelo con el SDK de Python de OCI

Cree un modelo con Python y guárdelo directamente en el catálogo de modelos.

Para crear y guardar un modelo, primero debe crear el artefacto de modelo.

Recomendamos que cree y guarde modelos en el catálogo de modelos mediante programación, ya sea mediante ADS o el SDK de Python de OCI.

Importante

  1. (Opcional) Cambie la versión del SDK de Python de OCI con pip install oci –upgrade.
  2. Guardado de un objeto de modelo en el disco. Puede utilizar varias herramientas para guardar un modelo (Joblib, cloudpickle, Pickle, ONNX, etc.). Se recomienda guardar un objeto de modelo en el directorio de nivel superior del artefacto de modelo y en el mismo nivel que los archivos score.py y runtime.yaml.
  3. Cambie el archivo score.py para definir las funciones load_model() y predict(). Cambie el cuerpo de ambas funciones para soportar el modelo de la siguiente manera:
    load_model()

    Lee el archivo de modelo en el disco y devuelve el objeto de estimador. Asegúrese de utilizar la misma biblioteca para serializar y anular la serialización del objeto de modelo.

    predict()

    Contiene dos parámetros, data y model. El parámetro necesario es data, que representa una carga útil de juego de datos, mientras que el modelo es un parámetro opcional. Por defecto, model es el objeto devuelto por load_model(). Asegúrese de que el tipo de dato del parámetro de datos coincida con el formato de carga útil que espera con el despliegue de modelo.

    Por defecto, el despliegue de modelo asume que data es una carga útil de JSON (MIME type application/json). La función predict() convierte la carga útil JSON en un formato de datos de objeto de modelo. Por ejemplo, un marco de datos de Pandas o una matriz de Numpy cuando ese sea el formato de datos soportado por el objeto de modelo. El cuerpo de predict() puede incluir transformaciones de datos y otras tareas de manipulación de datos antes de que se realice una predicción de modelo.

    Algunas cosas más que debe considerar:

    • No puede editar las firmas de función de load_model() y predict(). Solo puede editar el cuerpo de estas funciones para personalizarlas.
    • Si están disponibles en el archivo de artefacto, cualquier módulo de Python personalizado se puede importar mediante score.py o como parte del entorno conda utilizado con fines de inferencia.

    • Puede guardar más de un objeto de modelo en el artefacto. Puede cargar más de un objeto de estimador en la memoria para realizar una evaluación de conjunto. En este caso, load_model() puede devolver una matriz de objetos de modelo que predict() procesa.

  4. (Opcional) Pruebe la función score.predict().

    Se recomienda probar la función predict() en el entorno local antes de guardar el modelo en el catálogo de modelos. El siguiente fragmento de código muestra cómo transferir una carga útil de JSON para predecir que imita el comportamiento del modelo desplegado mediante el despliegue del modelo. Esta es una buena manera de garantizar que load_model() lea el objeto de modelo. Y, también, que las predicciones devueltas por los modelos sean correctas y en el formato esperado. Si ejecuta este fragmento de código en una sesión de bloc de notas, también obtendrá la salida de los registradores que defina en score.py en la celda de salida. 

    import sys
from json import dumps
 
# The local path to your model artifact directory is added to the Python path.
# replace <your-model-artifact-path>
sys.path.insert(0, f"<your-model-artifact-path>")
 
# importing load_model() and predict() that are defined in score.py
from score import load_model, predict
 
# Loading the model to memory
_ = load_model()
 
# Take a sample of your training or validation dataset and store it as data.
# Making predictions on a JSON string object (dumps(data)). Here we assume
# that predict() is taking data in JSON format
predictions_test = predict(dumps(data), _)
# Compare the predictions captured in predictions_test with what you expect for data:
predictions_test
  5. Cambie el archivo runtime.yaml.

    Este archivo proporciona una referencia al entorno conda que desea utilizar para el entorno de tiempo de ejecución del despliegue de modelo. Como mínimo, el archivo debe contener los siguientes campos para un despliegue de modelo:

    MODEL_ARTIFACT_VERSION: '3.0'
MODEL_DEPLOYMENT:
  INFERENCE_CONDA_ENV:
    INFERENCE_ENV_SLUG: <the-slugname> # for example mlcpuv1 see: https://docs.oracle.com/en-us/iaas/data-science/using/conda-gml-fam.htm
    INFERENCE_ENV_TYPE: <env-type> # can either be "published" or "data_science"
    INFERENCE_ENV_PATH: <conda-path-on-object-storage>
    INFERENCE_PYTHON_VERSION: <python-version-of-conda-environment>

    A continuación se incluye un ejemplo de un archivo runtime.yaml. El científico de datos selecciona el entorno conda Data Science TensorFlow 2.3 para CPU.

    MODEL_ARTIFACT_VERSION: '3.0'
MODEL_DEPLOYMENT:
  INFERENCE_CONDA_ENV:
    INFERENCE_ENV_SLUG: tensorflow23_p37_cpu_v1
    INFERENCE_ENV_TYPE: data_science
    INFERENCE_ENV_PATH: oci://service-conda-packs@id19sfcrra6z/service_pack/cpu/Tensorflow for CPU Python 3.7/1.0/tensorflow23_p37_cpu_v1
    INFERENCE_PYTHON_VERSION: '3.7'
  6. (Opcional) (Recomendado) Antes de guardar un modelo en el catálogo, le recomendamos que ejecute una serie de pruebas de introspección en el artefacto de modelo.

    El objetivo de estas pruebas es identificar los errores mediante la validación de los archivos score.py y runtime.yaml con un juego de comprobaciones para garantizar que tienen la sintaxis, los parámetros y las versiones correctos. Las pruebas de introspección están definidas como parte de la plantilla de código de artefacto de modelo.

    1. Se necesita Python versión 3.5 o superior para ejecutar las pruebas. Antes de ejecutar las pruebas localmente en la máquina, debe instalar las bibliotecas Python pyyaml y requests. Esta instalación es una operación de una sola vez.

      Vaya al directorio de artefactos. Ejecute el siguiente comando para instalar las dependencias de terceros necesarias: 

      python3 -m pip install --user -r artifact-introspection-test/requirements.txt
    2. Ejecute las pruebas localmente sustituiendo <artifact-directory> por la ruta de acceso al directorio de artefactos del modelo: 
      python3 artifact-introspection-test/model_artifact_validate.py --artifact <artifact-path>
    1. Inspeccione los resultados de la prueba.

      El script model_artifact_validate.py genera dos archivos de salida en el directorio de nivel superior de los artefactos de modelo:

      • test_json_output.json

      • test_html_output.html

      Puede abrir cualquier archivo para inspeccionar los errores. Si abre el archivo HTML, los mensajes de error se mostrarán en el fondo rojo.

    2. Repita los pasos 2 a 6 hasta que todas las pruebas se ejecuten correctamente. Una vez que las pruebas se han ejecutado correctamente, el artefacto del modelo estará listo para el guardado en el catálogo de modelos.
  7. Crear y guardar el modelo en el catálogo de modelos mediante el SDK de OCI con un archivo de configuración de OCI, que forma parte de la gestión de acceso estándar del SDK.
    1. Inicialice el cliente con: 
      # Create a default config using DEFAULT profile in default location
# Refer to
# https://docs.cloud.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm#SDK_and_CLI_Configuration_File
# for more info
 
import oci
from oci.data_science.models import CreateModelDetails, Metadata, CreateModelProvenanceDetails, UpdateModelDetails, UpdateModelProvenanceDetails
config = oci.config.from_file()
data_science_client = oci.data_science.DataScienceClient(config=config)
 
# Initialize service client with user principal (config file)
config = oci.config.from_file()
data_science_client = oci.data_science.DataScienceClient(config=config)
 
# Alternatively initialize service client with resource principal (for example in a notebook session)
# auth = oci.auth.signers.get_resource_principals_signer()
# data_science_client = oci.data_science.DataScienceClient({}, signer=auth)
    2. (Opcional) Documente la procedencia del modelo.

      Por ejemplo:

      provenance_details = CreateModelProvenanceDetails(repository_url="EXAMPLE-repositoryUrl-Value",
                                                  git_branch="EXAMPLE-gitBranch-Value",
                                                  git_commit="EXAMPLE-gitCommit-Value",
                                                  script_dir="EXAMPLE-scriptDir-Value",
                                                  # OCID of the ML job Run or Notebook session on which this model was
                                                  # trained
                                                  training_id="<Notebooksession or ML Job Run OCID>"
                                                  )
    3. (Opcional) Documente la taxonomía de modelo.

      Por ejemplo:

      # create the list of defined metadata around model taxonomy:
defined_metadata_list = [
    Metadata(key="UseCaseType", value="image_classification"),
    Metadata(key="Framework", value="keras"),
    Metadata(key="FrameworkVersion", value="0.2.0"),
    Metadata(key="Algorithm",value="ResNet"),
    Metadata(key="hyperparameters",value="{\"max_depth\":\"5\",\"learning_rate\":\"0.08\",\"objective\":\"gradient descent\"}")
]
    4. (Opcional) Agregue sus metadatos personalizados (atributos).

      Por ejemplo:

      # Adding your own custom metadata:
custom_metadata_list = [
    Metadata(key="Image Accuracy Limit", value="70-90%", category="Performance",
             description="Performance accuracy accepted"),
    Metadata(key="Pre-trained environment",
             value="https://blog.floydhub.com/guide-to-hyperparameters-search-for-deep-learning-models/",
             category="Training environment", description="Environment link for pre-trained model"),
    Metadata(key="Image Sourcing", value="https://lionbridge.ai/services/image-data/", category="other",
             description="Source for image training data")
]
    5. (Opcional) Documente las definiciones de esquema de datos de entrada y salida del modelo.
      Importante

      La definición de esquema tanto para el vector de función de entrada como para las predicciones de modelo se utilizan para fines de documentación. Esta directriz se aplica únicamente a juegos de datos tabulares.

      Por ejemplo:

      import json
from json import load
# Declare input/output schema for our model - this is optional
# It must be a valid json or yaml string
# Schema like model artifact is immutable hence it is allowed only at the model creation time and cannot be updated
# Schema json sample in appendix
input_schema = load(open('SR_input_schema.json','rb'))
input_schema_str= json.dumps(input_schema)
output_schema = load(open('SR_output_schema.json','rb'))
output_schema_str= json.dumps(output_schema)
    6. (Opcional) Documente los resultados de la prueba de introspección.
      Por ejemplo:
      # Provide the introspection test results
 
test_results = load(open('test_json_output.json','rb'))
test_results_str = json.dumps(test_results)
defined_metadata_list.extend([Metadata(key="ArtifactTestResults", value=test_results_str)])
    7. (Opcional) Defina el valor de timeout del cliente para evitar un error de timeout del servicio Data Science al guardar artefactos de modelo grandes: 
      import oci
 
config = oci.config.from_file()
data_science_client = oci.data_science.DataScienceClient(config=config)
# Change the timeout value to 1800 sec (30 mins)
data_science_client.base_client.timeout =  30 * 60
    8. Cree un archivo zip del artefacto de modelo: 
      import zipfile
import os
     
def zipdir(target_zip_path, ziph, source_artifact_directory):
    ''' Creates a zip archive of a model artifact directory.
     
    Parameters:
     
    - target_zip_path: the path where you want to store the zip archive of your artifact
    - ziph: a zipfile.ZipFile object
    - source_artifact_directory: the path to the artifact directory.
 
    Returns a zip archive in the target_zip_path you specify.    
 
    '''
    for root, dirs, files in os.walk(source_artifact_directory):
        for file in files:
            ziph.write(os.path.join(root, file),
                       os.path.relpath(os.path.join(root,file),
                                       os.path.join(target_zip_path,'.')))
       
zipf = zipfile.ZipFile('<relpath-to-artifact-directory>.zip', 'w', zipfile.zip_DEFLATED)
zipdir('.', zipf, "<relpath-to-artifact-directory>")
zipf.close()
    9. Cree (guarde) el modelo en el catálogo de modelos: 
      # creating a model details object:
model_details = CreateModelDetails(
    compartment_id='<compartment-ocid-of-model>',
    project_id='<project-ocid>',
    display_name='<display-name-of-model>',
    description='<description-of-model>',
    custom_metadata_list=custom_metadata_list,
    defined_metadata_list=defined_metadata_list,
    input_schema=input_schema_str,
    output_schema=output_schema_str)
 
# creating the model object:
model = data_science_client.create_model(model_details)
# adding the provenance:
data_science_client.create_model_provenance(model.data.id, provenance_details)
# adding the artifact:
with open('<relpath-to-artifact-directory>.zip','rb') as artifact_file:
    artifact_bytes = artifact_file.read()
    data_science_client.create_model_artifact(model.data.id, artifact_bytes, content_disposition='attachment; filename="<relpath-to-artifact-directory>.zip"')
  8. Ahora puede ver los detalles del modelo y ver la información del modelo, incluidos los metadatos opcionales que haya definido.

Utilice estos archivos de código de ejemplo y ejemplos de bloc de notas para ayudarle a diseñar un almacén de modelos.

¿Le ha resultado útil este artículo?