Traga Seu Próprio Contêiner

Crie ou especifique essas interfaces necessárias para usar uma implantação de modelo.

• A implantação de modelo só suporta imagem de contêiner que reside no OCI Registry.
• Certifique-se de que a imagem do contêiner exista no OCI Registry durante todo o ciclo de vida da implantação do modelo. A imagem deve existir para garantir a disponibilidade caso uma instância seja reiniciada automaticamente ou a equipe de serviço execute a aplicação de patches.
• Somente contêineres docker são suportados com BYOC.
• O Data Science usa o artefato de modelo compactado para trazer a lógica de pontuação do modelo de ML e espera que ele esteja disponível no catálogo de modelos do Data Science.
• O tamanho da imagem do contêiner é limitado a 16 GB em formato descompactado.
• O Data Science adiciona uma tarefa HEALTHCHECK antes de iniciar o contêiner para que a política HEALTHCHECK não precise ser adicionada explicitamente ao arquivo do Docker porque ela foi substituída. A verificação de integridade começa a ser executada 10 minutos após o início do contêiner e, em seguida, verifica /health a cada 30 segundos, com timeout de três segundos e três novas tentativas por verificação.
• Um pacote curl deve ser instalado na imagem do contêiner para que a política HEALTHCHECK do Docker tenha sucesso.
• O usuário que cria o recurso de implantação de modelo deve ter acesso à imagem do contêiner no OCI Registry para usá-la. Caso contrário, crie uma política de IAM de acesso do usuário antes de criar uma implantação de modelo.
• O docker CMD ou Entrypoint deve ser fornecido por meio da API ou do Dockerfile, que inicializa o servidor Web.
• O tempo limite definido pelo serviço para que o contêiner seja executado é de 10 minutos, portanto, certifique-se de que o contêiner de serviço de inferência seja iniciado (está íntegro) dentro desse período.
• Sempre teste o contêiner localmente antes de implantá-lo na Nuvem usando uma implantação de modelo.

As imagens de um registro do Docker são identificadas por repositório, nome e uma tag. Além disso, o Docker fornece a cada versão de uma imagem uma compilação alfanumérica exclusiva. Ao enviar uma imagem do Docker atualizada, recomendamos fornecer à imagem atualizada uma nova tag para identificá-la, em vez de reutilizar uma tag existente. No entanto, mesmo que você envie uma imagem atualizada e dê a ela o mesmo nome e tag de uma versão anterior, a versão recém-promovida tem outra compilação da versão anterior.

Ao criar um recurso de implantação de modelo, especifique o nome e a tag de uma versão específica de uma imagem na qual basear a implantação de modelo. Para evitar inconsistências, a implantação de modelo registra a compilação exclusiva dessa versão da imagem. Você também pode fornecer a compilação da imagem ao criar uma implantação de modelo.

Por padrão, quando você envia uma versão atualizada de uma imagem para o registro do Docker com o mesmo nome e tag da versão original da imagem na qual a implantação do modelo está baseada, ela continua usando a compilação original para extrair a versão original da imagem. Se quiser que a implantação de modelo extraia a versão mais recente da imagem, você poderá alterar explicitamente o nome da imagem com uma tag e compilação que a implantação de modelo usa para identificar qual versão da imagem extrair.

Crie um arquivo zip de artefato e salve-o com o modelo no catálogo de modelos. O artefato inclui o código para operar o contêiner e executar as solicitações de inferência.

O contêiner precisa expor um ponto final /health para retornar a integridade do servidor de inferência e um ponto final /predict para inferência.

O seguinte arquivo Python no artefato de modelo define esses pontos finais usando um servidor Flask com a porta 5000:

# We now need the json library so we can load and export json data
import json
import os
import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.neural_network import MLPClassifier
import pandas as pd
from joblib import load
from sklearn import preprocessing
import logging

from flask import Flask, request

# Set environnment variables
WORK_DIRECTORY = os.environ["WORK_DIRECTORY"]
TEST_DATA = os.path.join(WORK_DIRECTORY, "test.json")
MODEL_DIR = os.environ["MODEL_DIR"]
MODEL_FILE_LDA = os.environ["MODEL_FILE_LDA"]
MODEL_PATH_LDA = os.path.join(MODEL_DIR, MODEL_FILE_LDA)

# Loading LDA model
print("Loading model from: {}".format(MODEL_PATH_LDA))
inference_lda = load(MODEL_PATH_LDA)

# Creation of the Flask app
app = Flask(__name__)


# API 1
# Flask route so that we can serve HTTP traffic on that route
@app.route('/health')
# Get data from json and return the requested row defined by the variable Line
def health():
    # We can then find the data for the requested row and send it back as json
    return {"status": "success"}

# API 2
# Flask route so that we can serve HTTP traffic on that route
@app.route('/predict',methods=['POST'])
# Return prediction for both Neural Network and LDA inference model with the requested row as input
def prediction():
    data = pd.read_json(TEST_DATA)
    request_data = request.get_data()
    print(request_data)
    print(type(request_data))
    if isinstance(request_data, bytes):
        print("Data is of type bytes")
        request_data = request_data.decode("utf-8")
    print(request_data)
    line = json.loads(request_data)['line']
    data_test = data.transpose()
    X = data_test.drop(data_test.loc[:, 'Line':'# Letter'].columns, axis = 1)
    X_test = X.iloc[int(line),:].values.reshape(1, -1)

    clf_lda = load(MODEL_PATH_LDA)
    prediction_lda = clf_lda.predict(X_test)

    return {'prediction LDA': int(prediction_lda)}


if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0', port = 5000)

Você pode usar qualquer imagem do OCI Container Registry. Veja a seguir uma amostra do Dockerfile que usa o servidor Flask:

FROM jupyter/scipy-notebook
  
USER root
RUN \
  apt-get update && \
  apt-get -y install curl
  
ENV WORK_DIRECTORY=/opt/ds/model/deployed_model
ENV MODEL_DIR=$WORK_DIRECTORY/models
RUN mkdir -p $MODEL_DIR
  
ENV MODEL_FILE_LDA=clf_lda.joblib
  
COPY requirements.txt /opt/requirements.txt
RUN pip install -r /opt/requirements.txt

Crie um arquivo requirements.txt com os seguintes pacotes no mesmo diretório do Dockerfile:

flask
flask-restful
joblib

Execute o comando docker build:

docker build -t ml_flask_app_demo:1.0.0 -f Dockerfile .

Certifique-se de que o artefato de modelo e o código de inferência estejam no mesmo diretório do Dockerfile. Execute o contêiner em sua máquina local. Você precisa consultar os arquivos armazenados em sua máquina local montando o diretório de modelo local em /opt/ds/model/deployed_model:

docker run -p 5000:5000 \
  --health-cmd='curl -f http://localhost:5000/health || exit 1' \
  --health-interval=30s \
  --health-retries=3 \
  --health-timeout=3s \
  --health-start-period=1m \
  --mount type=bind,src=$(pwd),dst=/opt/ds/model/deployed_model \
  ml_flask_app_demo:1.0.0 python /opt/ds/model/deployed_model/api.py

Envie uma solicitação de integridade para verificar se o contêiner está em execução dentro do serviço definido por 10 minutos:

curl -vf http://localhost:5000/health

Teste enviando uma solicitação de previsão:

curl -H "Content-type: application/json" -X  POST http://localhost:5000/predict --data '{"line" : "12"}'

Para poder enviar e extrair imagens de/ para o Oracle Cloud Infrastructure Registry (também conhecido como Registro de Contêiner), você deve ter um token de autorização do Oracle Cloud Infrastructure. Você vê apenas a string do token de autenticação quando a cria, portanto, copie o token de autenticação para um local seguro imediatamente.

1. Para exibir os detalhes na Console: Na barra de navegação, selecione o menu Perfil e, em seguida, selecione Definições do usuário ou Meu perfil, dependendo da opção exibida.
2. Na página Tokens de Autenticação, selecione Gerar Token.
3. Digite uma descrição amigável para o token de autenticação. Evite fornecer informações confidenciais.
4. Selecione Gerar Token. O novo token de autenticação será exibido.
5. Copie o token de autenticação imediatamente para um local seguro em que você poderá recuperá-lo posteriormente. Você não verá o token de autenticação novamente na Console.
6. Feche a caixa de diálogo Gerar Token.
7. Abra uma janela de terminal em sua máquina local.
8. Acesse o Container Registry para que você possa criar, executar, testar, marcar e enviar a imagem do contêiner.

   docker login -u '<tenant-namespace>/<username>' <region>.ocir.io

9. Marque a imagem do contêiner local:

   docker tag <local_image_name>:<local_version> <region>.ocir.io/<tenancy_ocir_namespace>/<repository>:<version>

10. Envie a imagem do contêiner:

    docker push <region>.ocir.io/<tenancy>/byoc:1.0

    Observação
    
    

    Certifique-se de que o recurso de implantação de modelo tenha uma política para o controlador de recursos para que ele possa ler a imagem do OCI Registry no compartimento no qual você armazenou a imagem. Conceder Acesso de Implantação de Modelo a um Contêiner Personalizado Usando o Controlador de Recursos

As operações de atualização BYOC são atualizações parciais do tipo mesclagem superficial.

Um campo de nível superior gravável deve ser completamente substituído quando aparece definido no conteúdo da solicitação e, caso contrário, preservado inalterado. Por exemplo, para um recurso como o seguinte:

{ 
    "environmentConfigurationDetails": {
        "environmentConfigurationType": "OCIR_CONTAINER",  
        "serverPort": 5454,
        "image": "iad.ocir.io/testtenancy/md_byoc_ref_iris_data:1.0.1",
        "imageDigest": "sha256:a9c8468cb671929aec7ad947b9dccd6fe8e6d77f7bcecfe2e10e1c935a88c2a5",
        "environmentVariables": {
            "a": "b",
            "c": "d",
            "e": "f"
        },
        "entrypoint": [ "python", "-m", "uvicorn", "a/model/server:app", "--port", "5000","--host","0.0.0.0"]
        "cmd": ["param1"]
}

Uma atualização bem-sucedida com o seguinte:

{
    "environmentConfigurationDetails": {
        "serverPort": 2000, 
        "environmentVariables": {"x":"y"},
        "entrypoint": []
    }
}

Resulta em um estado em que serverPort e environmentVariables são substituídos pelo conteúdo de atualização (incluindo a destruição de dados presentes anteriormente em campos detalhados que estão ausentes no conteúdo de atualização). O image é preservado inalterado porque não aparece no conteúdo da atualização e o entrypoint é apagado por uma lista vazia explícita:

{ 
    "environmentConfigurationDetails": {
        "environmentConfigurationType": "OCIR_CONTAINER",  
        "serverPort": 2000,
        "image": "iad.ocir.io/testtenancy/md_byoc_ref_iris_data:1.0.1",
        "imageDigest": "sha256:a9c8468cb671929aec7ad947b9dccd6fe8e6d77f7bcecfe2e10e1c935a88c2a5",
        "environmentVariables": {"x": "y"},
        "entrypoint": []
        "cmd": ["param1"]
}

Uma atualização bem-sucedida usando { "environmentConfigurationDetails": null or {} } resulta em nada sendo substituído. Uma substituição completa no nível superior apaga todos os valores que não estão no conteúdo da solicitação, portanto, evite isso. Todos os campos são opcionais no objeto de atualização, portanto, se você não fornecer a imagem, ela não deverá cancelar a definição da imagem na implantação. O Data Science só substituirá os campos de segundo nível se eles não forem nulos.

Não definir um campo no objeto de solicitação (passando um valor nulo) significa que o Data Science não considerará esse campo para encontrar a diferença e a substituição pelo valor de campo existente.

Para redefinir um valor de qualquer campo, informe um objeto vazio. Para campos de tipo de lista e mapa, o Data Science pode aceitar uma lista vazia ([]) ou um mapa ({}) como uma indicação para apagar os valores. Em qualquer caso, nulo não significa apagar os valores. No entanto, você sempre pode alterar o valor para outra coisa. Para usar uma porta padrão e cancelar a definição do valor do campo para ela, defina explicitamente a porta padrão.

A atualização para os campos de lista e mapa é uma substituição completa. O Data Science não procura valores individuais dentro dos objetos.

Para imagem e compilação, o Data Science não permite apagar o valor.