Criando e Salvando um Modelo com o OCI Python SDK

Crie um modelo com Python e salve-o diretamente no catálogo de modelos.

Para criar e salvar um modelo, primeiro crie o artefato de modelo.

Recomendamos que você crie e salve modelos no catálogo de modelos de forma programática, usando o ADS ou o OCI Python SDK.

Importante

Recomendamos que você crie e salve modelos no catálogo de modelos de forma programática, usando o ADS ou o OCI Python SDK.
Você pode usar o ADS para criar modelos grandes. Modelos grandes têm limitações de artefatos de até 400 GB.

(Opcional) Faça upgrade do OCI Python SDK com pip install oci –upgrade.
Salve um objeto de modelo no disco. Você pode usar várias ferramentas para salvar um modelo (Joblib, cloudpickle, pickle, ONNX e assim por diante). Recomendamos que você salve um objeto de modelo no diretório de nível superior do artefato de modelo e no mesmo nível dos arquivos score.py e runtime.yaml.
Altere seu arquivo score.py para definir as funções load_model() e predict(). Altere o corpo de ambas as funções para suportar seu modelo da seguinte forma:
load_model()

Lê o arquivo de modelo no disco e retorna o objeto estimador. Certifique-se de usar a mesma biblioteca para serializar e desserializar o objeto de modelo.

predict()

Contém dois parâmetros, data e model. O parâmetro obrigatório é data, que representa um payload de conjunto de dados, enquanto o modelo é um parâmetro opcional. Por padrão, model é o objeto retornado por load_model(). Verifique se o tipo de dados do parâmetro de dados corresponde ao formato de payload que você espera com a implantação do modelo.

Por padrão, a implantação do modelo pressupõe que data seja um payload JSON (MIME type application/json). A função predict() converte o payload JSON em um formato de dados de objeto de modelo. Por exemplo, um dataframe Pandas ou um array Numpy quando esse é o formato de dados suportado pelo objeto de modelo. O corpo de predict() pode incluir transformações de dados e outras tarefas de manipulação de dados antes de uma previsão de modelo ser feita.

Mais algumas coisas a serem consideradas:
- Não é possível editar as assinaturas de função de load_model() e predict(). Você só pode editar o corpo dessas funções para personalizá-las.
- Se estiverem disponíveis no arquivo de artefato, todos os módulos Python personalizados poderão ser importados usando score.py ou como parte do ambiente conda usado para fins de inferência.
- Você pode salvar mais de um objeto de modelo no artefato. Você pode carregar mais de um objeto estimador na memória para executar uma avaliação de montagem. Nesse caso, load_model() pode retornar um array de objetos de modelo que predict() processa.

(Opcional) Teste a função score.predict().

Recomendamos que você teste a função predict() em seu ambiente local antes de salvar o modelo no catálogo de modelos. O trecho de código a seguir mostra como especificar um payload JSON para prever se imitará o comportamento do modelo implantado usando a implantação de modelo. Essa é uma boa maneira de garantir que o objeto de modelo seja lido por load_model(). Além disso, que as previsões retornadas pelos modelos estejam corretas e no formato esperado. Se você executar esse trecho de código em uma sessão de notebook, obterá também a saída de quaisquer loggers definidos em score.py na célula de saída.

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

Altere o arquivo runtime.yaml.

Esse arquivo fornece uma referência ao ambiente conda que deseja usar para o ambiente de runtime para implantação de modelo. No mínimo, o arquivo deve conter os seguintes campos para uma implantação 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/Content/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>

Veja a seguir o exemplo de um arquivo runtime.yaml. O cientista de dados está selecionando o ambiente conda TensorFlow.

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'

(Opcional) (Recomendado) Antes de salvar um modelo no catálogo, recomendamos que você execute uma série de testes de introspecção em seu artefato de modelo.

A finalidade desses testes é identificar erros validando os arquivos score.py e runtime.yaml com um conjunto de verificações para garantir que eles tenham a sintaxe, os parâmetros e as versões corretas. Os testes de introspecção são definidos como parte do modelo de código de artefato de modelo.
1. O Python versão 3.5 ou mais recente é obrigatório para executar os testes. Antes de executar os testes localmente em sua máquina, instale as bibliotecas Python pyyaml e requests. Essa instalação é uma operação única.
  Vá para o diretório de artefatos. Execute o seguinte comando para instalar as dependências de terceiros obrigatórias:
```
python3 -m pip install --user -r artifact-introspection-test/requirements.txt
```
2. Execute os testes localmente substituindo <artifact-directory> pelo caminho para o diretório de artefatos de modelo:
```
python3 artifact-introspection-test/model_artifact_validate.py --artifact <artifact-path>
```
1. Inspecione os resultados do teste.
  O script model_artifact_validate.py gera dois arquivos de saída no diretório de nível superior de seus artefatos de modelo:
  - test_json_output.json
  - test_html_output.html
  Você pode abrir qualquer arquivo para inspecionar os erros. Se você estiver abrindo o arquivo HTML, as mensagens de erro serão exibidas em um plano de fundo vermelho.
2. Repete as etapas de 2 a 6 até todos os testes serem executados com sucesso. Depois que os testes forem executados com sucesso, o artefato de modelo estará pronto para ser salvo no catálogo de modelos.

Crie e salve o modelo no catálogo de modelos usando o OCI SDK com um arquivo de configuração do OCI, que faz parte do gerenciamento de acesso padrão do SDK.

Inicialize o cliente com:

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

(Opcional) Documentar a proveniência de modelo.

Por exemplo:

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

(Opcional) Documentar a taxonomia de modelo.

Por exemplo:

# 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\"}")
]

(Opcional) Adicionar metadados personalizados (atributos).

Por exemplo:

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

(Opcional) Documentar as definições de esquema de dados de entrada e saída do modelo.

Importante

A definição de esquema para as previsões de modelo e vetor de recurso de entrada é usada para fins de documentação. Essa diretriz só se aplica a conjuntos de dados tabulares.

Por exemplo:

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)

(Opcional) Documentar os resultados do teste de introspecção.

Por exemplo:

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

(Opcional) Defina o valor de timeout do cliente para evitar um erro de timeout do serviço Data Science ao salvar artefatos 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

Crie um arquivo zip do artefato 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()

Crie (salve) o modelo no 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"')

Agora você pode exibir os detalhes do modelo e exibir as informações do modelo, incluindo quaisquer metadados opcionais que você definiu.

Use estes arquivos de código de amostra e exemplos de notebook para ajudar você a criar um armazenamento de modelos.

Documentação do Oracle Cloud Infrastructure

Criando e Salvando um Modelo com o OCI Python SDK