Création et enregistrement d'un modèle avec le kit SDK Python OCI
Créez un modèle avec Python et enregistrez-le directement dans le catalogue de modèles.
Pour créer et enregistrer un modèle, vous devez d'abord créer l'artefact de modèle.
Nous vous recommandons de créer et d'enregistrer des modèles dans le catalogue de modèles par programmation, à l'aide d'ADS ou du kit SDK Python OCI.
-
Nous vous recommandons de créer et d'enregistrer des modèles dans le catalogue de modèles par programmation, à l'aide d'ADS ou du kit SDK Python OCI.
-
Vous pouvez utiliser ADS pour créer des modèles volumineux. Les grands modèles ont des limitations d'artefacts allant jusqu'à 400 Go.
- (Facultatif) Mettez à niveau le kit SDK Python OCI avec
.pip install oci –upgrade
-
Enregistrez un objet de modèle sur le disque. Vous pouvez utiliser différents outils pour enregistrer un modèle (Joblib, cloudpickle, pickle, ONNX, etc.). Nous vous recommandons d'enregistrer un objet de modèle dans le répertoire de niveau supérieur de l'artefact de modèle, au même niveau que les fichiers
score.py
etruntime.yaml
. -
Changez votre fichier
score.py
pour définir les fonctionsload_model()
etpredict()
. Modifiez le corps des deux fonctions pour prendre en charge votre modèle comme suit :load_model()
-
Lit le fichier de modèle sur le disque et renvoie l'objet d'estimateur. Veillez à utiliser la même bibliothèque pour la sérialisation et la désérialisation de l'objet de modèle.
predict()
-
Contient deux paramètres :
data
etmodel
. Le paramètre requis estdata
, qui représente la charge utile d'un ensemble de données, tandis que model est un paramètre facultatif. Par défaut,model
est l'objet renvoyé parload_model()
. Assurez-vous que le type de données du paramètre data correspond au format de charge utile attendu avec le déploiement de modèle.Par défaut, le déploiement de modèle suppose que
data
est une charge utile JSON (MIME type application/json
). La fonctionpredict()
convertit la charge utile JSON en un format de données d'objet de modèle. Par exemple : trame de données Pandas ou tableau Numpy lorsqu'il s'agit du format de données pris en charge par l'objet de modèle. Le corps depredict()
peut inclure des transformations de données et d'autres tâches de manipulation de données avant la réalisation d'une prédiction de modèle.
Quelques points supplémentaires à prendre en compte :
- Vous ne pouvez pas modifier les signatures de fonction de
load_model()
etpredict()
. Vous pouvez uniquement modifier le corps de ces fonctions pour les personnaliser. - S'ils sont disponibles dans le fichier d'artefact, les modules Python personnalisés peuvent être importés à l'aide de
score.py
ou dans le cadre de l'environnement conda utilisé à des fins d'inférence. -
Vous pouvez enregistrer plusieurs objets de modèle dans votre artefact. Vous pouvez charger plusieurs objets d'estimateur en mémoire pour effectuer une évaluation d'ensemble. Dans ce cas,
load_model()
peut renvoyer un tableau d'objets de modèle traité parpredict()
.
- (Facultatif) Testez la fonction
score.predict()
.Nous vous recommandons de tester la fonction
predict()
dans votre environnement local avant d'enregistrer le modèle dans le catalogue de modèles. Le fragment de code suivant montre comment transmettre une charge utile JSON pour prédiction qui imite le comportement du modèle déployé à l'aide du déploiement de modèle. Il s'agit d'un bon moyen de s'assurer que l'objet de modèle est lu parload_model()
, et que les prédictions renvoyées par vos modèles sont correctes et au format attendu. Si vous exécutez ce fragment de code dans une session de bloc-notes, vous obtenez également la sortie des journaliseurs que vous définissez dansscore.py
dans la cellule de sortie.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 -
Modifiez le fichier
runtime.yaml
.Ce fichier fournit une référence à l'environnement conda à utiliser pour l'environnement d'exécution du déploiement de modèle. Au minimum, le fichier doit contenir les champs suivants pour un déploiement de modèle :
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>
Voici un exemple de fichier
runtime.yaml
. L'analyste de données sélectionne l'environnement 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'
- (Facultatif mais recommandé) Avant d'enregistrer un modèle dans le catalogue, nous vous recommandons d'exécuter une série de tests d'introspection sur l'artefact de modèle.
L'objectif de ces tests est d'identifier les erreurs en validant les fichiers
score.py
etruntime.yaml
avec un ensemble de vérifications pour s'assurer que la syntaxe, les paramètres et les versions sont corrects. Les tests d'introspection sont définis dans le cadre du modèle de code d'artefact de modèle.-
Python version 3.5 ou ultérieure est requis pour exécuter les tests. Avant d'exécuter les tests localement sur votre ordinateur, vous devez installer les bibliothèques Python
pyyaml
etrequests
. Cette installation est une opération ponctuelle.Accédez au répertoire de l'artefact. Exécutez la commande suivante pour installer les dépendances tierces requises :
python3 -m pip install --user -r artifact-introspection-test/requirements.txt
-
Exécutez les tests localement en remplaçant
<artifact-directory>
par le chemin d'accès au répertoire d'artefact de modèle :python3 artifact-introspection-test/model_artifact_validate.py --artifact
<artifact-path>
-
Examinez les résultats du test.
Le script
model_artifact_validate.py
génère deux fichiers de sortie dans le répertoire de niveau supérieur de vos artefacts de modèle :-
test_json_output.json
-
test_html_output.html
Vous pouvez ouvrir l'un ou l'autre des fichiers pour examiner les erreurs. Si vous ouvrez le fichier HTML, les messages d'erreur sont affichés dans l'arrière-plan rouge.
-
- Répétez les étapes 2 à 6 jusqu'à ce que tous les tests aboutissent. Une fois les tests exécutés, l'artefact de modèle est prêt à être enregistré dans le catalogue de modèles.
-
Python version 3.5 ou ultérieure est requis pour exécuter les tests. Avant d'exécuter les tests localement sur votre ordinateur, vous devez installer les bibliothèques Python
-
Créez et enregistrez le modèle dans le catalogue de modèles à l'aide du kit SDK OCI avec un fichier de configuration OCI, qui fait partie de la gestion standard des accès au kit SDK.
-
Initialisez le client :
# 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)
- (Facultatif) Documentez la provenance du modèle.
Par exemple :
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>
" ) - (Facultatif) Documentez la taxonomie du modèle.
Par exemple :
# 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\"}") ]
- (Facultatif) Ajoutez vos métadonnées personnalisées (attributs).
Par exemple :
# 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") ]
- (Facultatif) Documentez les définitions de schéma de données d'entrée et de sortie du modèle.
Important
La définition de schéma pour les prédictions de modèle et de vecteur de caractéristique d'entrée est utilisée à des fins de documentation. Cette directive s'applique uniquement aux ensembles de données tabulaires.
Par exemple :
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)
- (Facultatif) Documentez les résultats de test d'introspection.
Par exemple :
# 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)])
- (Facultatif) Définissez la valeur du délai d'expiration du client pour éviter une erreur de délai d'expiration du service Data Science lors de l'enregistrement des artefacts de modèle volumineux :
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
-
Créez une archive ZIP de l'artefact de modèle :
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()
-
Créez (enregistrez) le modèle dans le catalogue de modèles :
# 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"')
-
Initialisez le client :
- Vous pouvez maintenant afficher les détails du modèle et visualiser les informations sur le modèle, y compris les métadonnées facultatives que vous avez définies.
Utilisez ces exemples de fichiers de code et des exemples de bloc-notes pour vous aider à concevoir un magasin de modèles.