From 1401db08b49d4d472933bdc9b7755ca866c4c156 Mon Sep 17 00:00:00 2001 From: Aleksandr Panchul Date: Tue, 20 Oct 2020 15:02:18 -0700 Subject: [PATCH 1/4] adding sample model for ONNX inference --- .../04-KFServing/onnx-mnist-input.json | 1 + .../04-KFServing/onnx-mnist-model.onnx | Bin 0 -> 26454 bytes .../04-KFServing/onnx.md | 67 +++++++++ .../04-KFServing/onnx.yaml | 11 ++ .../04-KFServing/onnx_mnist.py | 128 ++++++++++++++++++ 5 files changed, 207 insertions(+) create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-input.json create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-model.onnx create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_mnist.py diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-input.json b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-input.json new file mode 100644 index 000000000..5b69977b6 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-input.json @@ -0,0 +1 @@ +{"inputs": {"Input3": {"dims": ["1", "1", "28", "28"], "dataType": 1, "rawData": "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"}}, "outputFilter": ["Plus214_Output_0"]} \ No newline at end of file diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-model.onnx b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mnist-model.onnx new file mode 100644 index 0000000000000000000000000000000000000000..bb189a52ea6ed40f3d5f94f0834f1fdab49022fe GIT binary patch literal 26454 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 literal 0 HcmV?d00001 diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md new file mode 100644 index 000000000..e1b42fb73 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md @@ -0,0 +1,67 @@ +# KFServing of ONNX models + +## Building models + +ONNX is a format for models, the models themselves could be of any ML framework or your own application +The artefact of the model build should be in .onnx format. + +For example, see how you could [Register and Deploy ONNX Model]( +https://github.com/Azure/MachineLearningNotebooks/blob/2aa7c53b0ce84e67565d77e484987714fdaed36e/how-to-use-azureml/deployment/onnx/onnx-model-register-and-deploy.ipynb) + +We will be using `onnx-mnist-model.onnx` from that example. You would need to move it to the `pvc` in your cluster as we did in other labs, or +upload it to your `gs://` or `s3://` storage. + +## Deploying model + +Deployed model is a CRD `inferenceservice`. You can crete it in the same namespace we created earlier in this lab like so: + + $ kubectl create -f onnx.yaml -n kfserving-test + inferenceservice.serving.kubeflow.org/mnist-onnx created + +In a few minutes you should see the pods running: + + $ kubectl get pods -n kfserving-test + NAME READY STATUS RESTARTS AGE + mnist-onnx-predictor-default-5jk48-deployment-b7c89954c-6s6wn 3/3 Running 0 36s + +And, more importantly, the `inferenceservice` in the `READY` state: + + $ kubectl get inferenceservice -n kfserving-test + NAME URL READY DEFAULT TRAFFIC CANARY TRAFFIC AGE + mnist-onnx http://mnist-onnx.kfserving-test.example.com/v1/models/mnist-onnx True + + +You can now [determine your ingress IP and port](https://github.com/kubeflow/kfserving/blob/master/README.md#determine-the-ingress-ip-and-ports): + +For KFServing deployment within Kubeflow: + + $ export INGRESS_HOST=$(kubectl -n istio-system get service kfserving-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}') + $ export INGRESS_PORT=$(kubectl -n istio-system get service kfserving-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}') + +For other stand-alone KFServing deployments: + + $ export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}') + $ export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}') + +Before you run inference on your model, it is useful to define environment variables: + + $ export MODEL_NAME=mnist-onnx + $ export SERVICE_HOSTNAME=$(kubectl get inferenceservice ${MODEL_NAME} -n kfserving-test -o jsonpath='{.status.url}' | cut -d "/" -f 3) + +## Inference with the deployed model + +You need to convert your input into a JSON format, as example, we provide `onnx-mnist-input.json` to show the tags. + + $ export INPUT_PATH=onnx-mnist-input.json + $ curl -v -H "Host: ${SERVICE_HOSTNAME}" http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_NAME:predict -d $INPUT_PATH + +In some cases, depending on the model, you would need to do the post-processing of the output. + +## Links + +- https://www.tensorflow.org/guide/saved_model +- https://github.com/kubeflow/kfserving/tree/master/docs/samples/onnx + +--- + +[Back](Readme.md) diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml new file mode 100644 index 000000000..91c9b31d0 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml @@ -0,0 +1,11 @@ +apiVersion: "serving.kubeflow.org/v1alpha2" +kind: "InferenceService" +metadata: + name: "mnist-onnx" +spec: + default: + predictor: + onnx: + # Another ONNX model, from KFServing samples + # storageUri: "gs://kfserving-examples/onnx/style" + storageUri: "pvc://pvc://samba-share-claim/mymodels/build_models/mnist-onnx" diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_mnist.py b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_mnist.py new file mode 100644 index 000000000..7ea580fac --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_mnist.py @@ -0,0 +1,128 @@ + +# This is a modified version of +# https://github.com/Azure/MachineLearningNotebooks/tree/master/how-to-use-azureml/deployment/onnx/mnist.py +# Which is a modified version of https://github.com/pytorch/examples/blob/master/mnist/main.py which is +# licensed under BSD 3-Clause (https://github.com/pytorch/examples/blob/master/LICENSE) + +from __future__ import print_function +import argparse +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +from torchvision import datasets, transforms +import os + + +class Net(nn.Module): + def __init__(self): + super(Net, self).__init__() + self.conv1 = nn.Conv2d(1, 10, kernel_size=5) + self.conv2 = nn.Conv2d(10, 20, kernel_size=5) + self.conv2_drop = nn.Dropout2d() + self.fc1 = nn.Linear(320, 50) + self.fc2 = nn.Linear(50, 10) + + def forward(self, x): + x = F.relu(F.max_pool2d(self.conv1(x), 2)) + x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) + x = x.view(-1, 320) + x = F.relu(self.fc1(x)) + x = F.dropout(x, training=self.training) + x = self.fc2(x) + return F.log_softmax(x, dim=1) + + +def train(args, model, device, train_loader, optimizer, epoch, output_dir): + model.train() + for batch_idx, (data, target) in enumerate(train_loader): + data, target = data.to(device), target.to(device) + optimizer.zero_grad() + output = model(data) + loss = F.nll_loss(output, target) + loss.backward() + optimizer.step() + if batch_idx % args.log_interval == 0: + print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( + epoch, batch_idx * len(data), len(train_loader.dataset), + 100. * batch_idx / len(train_loader), loss.item())) + + +def test(args, model, device, test_loader): + model.eval() + test_loss = 0 + correct = 0 + with torch.no_grad(): + for data, target in test_loader: + data, target = data.to(device), target.to(device) + output = model(data) + test_loss += F.nll_loss(output, target, size_average=False, reduce=True).item() # sum up batch loss + pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability + correct += pred.eq(target.view_as(pred)).sum().item() + + test_loss /= len(test_loader.dataset) + print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( + test_loss, correct, len(test_loader.dataset), + 100. * correct / len(test_loader.dataset))) + + +def main(): + # Training settings + parser = argparse.ArgumentParser(description='PyTorch MNIST Example') + parser.add_argument('--batch-size', type=int, default=64, metavar='N', + help='input batch size for training (default: 64)') + parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', + help='input batch size for testing (default: 1000)') + parser.add_argument('--epochs', type=int, default=5, metavar='N', + help='number of epochs to train (default: 5)') + parser.add_argument('--lr', type=float, default=0.01, metavar='LR', + help='learning rate (default: 0.01)') + parser.add_argument('--momentum', type=float, default=0.5, metavar='M', + help='SGD momentum (default: 0.5)') + parser.add_argument('--no-cuda', action='store_true', default=False, + help='disables CUDA training') + parser.add_argument('--seed', type=int, default=1, metavar='S', + help='random seed (default: 1)') + parser.add_argument('--log-interval', type=int, default=10, metavar='N', + help='how many batches to wait before logging training status') + parser.add_argument('--output-dir', type=str, default='outputs') + args = parser.parse_args() + use_cuda = not args.no_cuda and torch.cuda.is_available() + + torch.manual_seed(args.seed) + + device = torch.device("cuda" if use_cuda else "cpu") + + output_dir = args.output_dir + os.makedirs(output_dir, exist_ok=True) + + kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} + train_loader = torch.utils.data.DataLoader( + datasets.MNIST('data', train=True, download=True, + transform=transforms.Compose([transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,))]) + ), + batch_size=args.batch_size, shuffle=True, **kwargs) + test_loader = torch.utils.data.DataLoader( + datasets.MNIST('data', train=False, + transform=transforms.Compose([transforms.ToTensor(), + transforms.Normalize((0.1307,), (0.3081,))]) + ), + batch_size=args.test_batch_size, shuffle=True, **kwargs) + + model = Net().to(device) + optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) + + for epoch in range(1, args.epochs + 1): + train(args, model, device, train_loader, optimizer, epoch, output_dir) + test(args, model, device, test_loader) + + # save model + dummy_input = torch.randn(1, 1, 28, 28, device=device) + model_path = os.path.join(output_dir, 'mnist.onnx') + torch.onnx.export(model, dummy_input, model_path) + + +if __name__ == '__main__': + main() + From fc080a54f0e6d4e4380e44d1827d1f8b4a370030 Mon Sep 17 00:00:00 2001 From: Aleksandr Panchul Date: Wed, 21 Oct 2020 11:24:32 -0700 Subject: [PATCH 2/4] correcting a typo in model uri --- Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml index 91c9b31d0..c5a2fd50b 100644 --- a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml @@ -8,4 +8,4 @@ spec: onnx: # Another ONNX model, from KFServing samples # storageUri: "gs://kfserving-examples/onnx/style" - storageUri: "pvc://pvc://samba-share-claim/mymodels/build_models/mnist-onnx" + storageUri: "pvc://samba-share-claim/mymodels/build_models/mnist-onnx" From e7746b9b5206e2cbfc4a0c80dd09d92b456954f9 Mon Sep 17 00:00:00 2001 From: Aleksandr Panchul Date: Wed, 21 Oct 2020 18:02:58 -0700 Subject: [PATCH 3/4] addinng kubeflow onnx notebook --- .../04-KFServing/onnx-mosaic.ipynb | 247 ++++++++++++++++++ .../04-KFServing/onnx.md | 29 +- .../04-KFServing/onnx.yaml | 6 +- .../04-KFServing/onnx_custom.md | 62 +++++ .../04-KFServing/onnx_custom.yaml | 9 + .../04-KFServing/onnx_input_image.jpg | Bin 0 -> 124814 bytes 6 files changed, 328 insertions(+), 25 deletions(-) create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mosaic.ipynb create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.md create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.yaml create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_input_image.jpg diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mosaic.ipynb b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mosaic.ipynb new file mode 100644 index 000000000..8cb09fa22 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx-mosaic.ipynb @@ -0,0 +1,247 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Predict an ONNX InferenceService" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example assumes you have already deployed the sample ONNX Inference Service. \n", + "\n", + "Deploy the sample ONNX InferenceSevice by following the instructions in the [README](https://github.com/kubeflow/kfserving/blob/master/docs/samples/onnx/README.md)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pillow in /home/jovyan/.local/lib/python3.6/site-packages (8.0.0)\n", + "\u001b[33mWARNING: You are using pip version 19.1.1, however version 20.2.4 is available.\n", + "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install pillow --user" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'http://:80/v1/models/style-sample:predict'" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# if you dont see values above, see instructions in the readme and replace the values here!\n", + "import os\n", + "\n", + "#model_name = os.environ[\"MODEL_NAME\"]\n", + "#service_hostname = os.environ[\"SERVICE_HOSTNAME\"]\n", + "#cluster_ip = os.environ[\"CLUSTER_IP\"]\n", + "\n", + "model_name = \"style-sample\"\n", + "service_hostname = \"style-sample.kfserving-test.example.com\"\n", + "cluster_ip = \":80\"\n", + "\n", + "predictor_url = \"http://%s/v1/models/%s:predict\" % (cluster_ip, model_name)\n", + "predictor_url" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "import google.protobuf.json_format as json_format\n", + "import assets.onnx_ml_pb2 as onnx_ml_pb2\n", + "import assets.predict_pb2 as predict_pb2\n", + "import requests" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# load & resize image\n", + "image = Image.open(\"onnx_input_image.jpg\")\n", + "image = image.resize((244,244), Image.ANTIALIAS)\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 3, 244, 244)" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# preprocess image data\n", + "norm_img_data = np.array(image).astype('float32')\n", + "norm_img_data = np.transpose(norm_img_data, [2, 0, 1])\n", + "norm_img_data = np.expand_dims(norm_img_data, axis=0)\n", + "np.shape(norm_img_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# Create request message to be sent to the predictor\n", + "import assets.onnx_ml_pb2 as onnx_ml_pb2\n", + "import assets.predict_pb2 as predict_pb2\n", + "import requests\n", + "\n", + "input_tensor = onnx_ml_pb2.TensorProto()\n", + "input_tensor.dims.extend(norm_img_data.shape)\n", + "input_tensor.data_type = 1\n", + "input_tensor.raw_data = norm_img_data.tobytes()\n", + "\n", + "request_message = predict_pb2.PredictRequest()\n", + "request_message.inputs[\"input1\"].data_type = input_tensor.data_type\n", + "request_message.inputs[\"input1\"].dims.extend(input_tensor.dims)\n", + "request_message.inputs[\"input1\"].raw_data = input_tensor.raw_data\n", + "\n", + "# write message data to JSON\n", + "message_data = json_format.MessageToJson(request_message)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Call predictor\n", + "request_headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Host': service_hostname}\n", + "#print(predictor_url)\n", + "response = requests.post(predictor_url, headers=request_headers, data=message_data)\n", + "response" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "# Parse response message\n", + "response_message = json_format.Parse(response.text, predict_pb2.PredictResponse())\n", + "output1 = np.frombuffer(response_message.outputs['output1'].raw_data, dtype=np.float32)\n", + "output1 = output1.reshape(3,244,244)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# postprocess\n", + "result = np.clip(output1, 0, 255)\n", + "result = result.transpose(1,2,0).astype(\"uint8\")\n", + "img = Image.fromarray(result)\n", + "img" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md index e1b42fb73..3194dcbc4 100644 --- a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.md @@ -1,34 +1,23 @@ -# KFServing of ONNX models - -## Building models - -ONNX is a format for models, the models themselves could be of any ML framework or your own application -The artefact of the model build should be in .onnx format. - -For example, see how you could [Register and Deploy ONNX Model]( -https://github.com/Azure/MachineLearningNotebooks/blob/2aa7c53b0ce84e67565d77e484987714fdaed36e/how-to-use-azureml/deployment/onnx/onnx-model-register-and-deploy.ipynb) - -We will be using `onnx-mnist-model.onnx` from that example. You would need to move it to the `pvc` in your cluster as we did in other labs, or -upload it to your `gs://` or `s3://` storage. +# KFServing of custom ONNX models ## Deploying model Deployed model is a CRD `inferenceservice`. You can crete it in the same namespace we created earlier in this lab like so: $ kubectl create -f onnx.yaml -n kfserving-test - inferenceservice.serving.kubeflow.org/mnist-onnx created + inferenceservice.serving.kubeflow.org/style-sample created In a few minutes you should see the pods running: $ kubectl get pods -n kfserving-test NAME READY STATUS RESTARTS AGE - mnist-onnx-predictor-default-5jk48-deployment-b7c89954c-6s6wn 3/3 Running 0 36s + style-sample-predictor-default-5jk48-deployment-b7c89954c-6s6wn 3/3 Running 0 36s And, more importantly, the `inferenceservice` in the `READY` state: $ kubectl get inferenceservice -n kfserving-test NAME URL READY DEFAULT TRAFFIC CANARY TRAFFIC AGE - mnist-onnx http://mnist-onnx.kfserving-test.example.com/v1/models/mnist-onnx True + style-sample http://style-sample.kfserving-test.example.com/v1/models/style-sample True You can now [determine your ingress IP and port](https://github.com/kubeflow/kfserving/blob/master/README.md#determine-the-ingress-ip-and-ports): @@ -45,17 +34,15 @@ For other stand-alone KFServing deployments: Before you run inference on your model, it is useful to define environment variables: - $ export MODEL_NAME=mnist-onnx + $ export MODEL_NAME=style-sample $ export SERVICE_HOSTNAME=$(kubectl get inferenceservice ${MODEL_NAME} -n kfserving-test -o jsonpath='{.status.url}' | cut -d "/" -f 3) ## Inference with the deployed model -You need to convert your input into a JSON format, as example, we provide `onnx-mnist-input.json` to show the tags. - - $ export INPUT_PATH=onnx-mnist-input.json - $ curl -v -H "Host: ${SERVICE_HOSTNAME}" http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_NAME:predict -d $INPUT_PATH +From the Kubeflow dashboard of the Azure Stack environment, create Jupyter Server, and open the notebook [onnx-mosaic.ipynb](onnx-mosaic.ipynb). +Provide the INGRESS_PORT, INGRESS_HOST, and SERVICE_HOSTNAME to do the inferencing. -In some cases, depending on the model, you would need to do the post-processing of the output. +For troubleshooting, see the latest versions at [Kubeflow KFServing ONNX](https://github.com/kubeflow/kfserving/tree/master/docs/samples/onnx) ## Links diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml index c5a2fd50b..fd2ddda71 100644 --- a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx.yaml @@ -1,11 +1,9 @@ apiVersion: "serving.kubeflow.org/v1alpha2" kind: "InferenceService" metadata: - name: "mnist-onnx" + name: "style-sample" spec: default: predictor: onnx: - # Another ONNX model, from KFServing samples - # storageUri: "gs://kfserving-examples/onnx/style" - storageUri: "pvc://samba-share-claim/mymodels/build_models/mnist-onnx" + storageUri: "gs://kfserving-examples/onnx/style" diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.md b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.md new file mode 100644 index 000000000..6e789a0f7 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.md @@ -0,0 +1,62 @@ +# KFServing of custom ONNX models + +For example, see how you could [Register and Deploy ONNX Model]( +https://github.com/Azure/MachineLearningNotebooks/blob/2aa7c53b0ce84e67565d77e484987714fdaed36e/how-to-use-azureml/deployment/onnx/onnx-model-register-and-deploy.ipynb) + +We will be using `onnx-mnist-model.onnx` from that example. You would need to move it to the `pvc` in your cluster as we did in other labs, or +upload it to your `gs://` or `s3://` storage. + +## Deploying model + +Deployed model is a CRD `inferenceservice`. You can crete it in the same namespace we created earlier in this lab like so: + + $ kubectl create -f onnx_custom.yaml -n kfserving-test + inferenceservice.serving.kubeflow.org/mnist-onnx created + +In a few minutes you should see the pods running: + + $ kubectl get pods -n kfserving-test + NAME READY STATUS RESTARTS AGE + mnist-onnx-predictor-default-5jk48-deployment-b7c89954c-6s6wn 3/3 Running 0 36s + +And, more importantly, the `inferenceservice` in the `READY` state: + + $ kubectl get inferenceservice -n kfserving-test + NAME URL READY DEFAULT TRAFFIC CANARY TRAFFIC AGE + mnist-onnx http://mnist-onnx.kfserving-test.example.com/v1/models/mnist-onnx True + + +You can now [determine your ingress IP and port](https://github.com/kubeflow/kfserving/blob/master/README.md#determine-the-ingress-ip-and-ports): + +For KFServing deployment within Kubeflow: + + $ export INGRESS_HOST=$(kubectl -n istio-system get service kfserving-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}') + $ export INGRESS_PORT=$(kubectl -n istio-system get service kfserving-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}') + +For other stand-alone KFServing deployments: + + $ export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}') + $ export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}') + +Before you run inference on your model, it is useful to define environment variables: + + $ export MODEL_NAME=mnist-onnx + $ export SERVICE_HOSTNAME=$(kubectl get inferenceservice ${MODEL_NAME} -n kfserving-test -o jsonpath='{.status.url}' | cut -d "/" -f 3) + +## Inference with the deployed model + +You need to convert your input into a JSON format, as example, we provide `onnx-mnist-input.json` to show the tags. + + $ export INPUT_PATH=onnx-mnist-input.json + $ curl -v -H "Host: ${SERVICE_HOSTNAME}" http://${INGRESS_HOST}:${INGRESS_PORT}/v1/models/$MODEL_NAME:predict -d $INPUT_PATH + +In some cases, depending on the model, you would need to do the post-processing of the output. + +## Links + +- https://www.tensorflow.org/guide/saved_model +- https://github.com/kubeflow/kfserving/tree/master/docs/samples/onnx + +--- + +[Back](Readme.md) diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.yaml b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.yaml new file mode 100644 index 000000000..301a5ea36 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_custom.yaml @@ -0,0 +1,9 @@ +apiVersion: "serving.kubeflow.org/v1alpha2" +kind: "InferenceService" +metadata: + name: "mnist-onnx" +spec: + default: + predictor: + onnx: + storageUri: "pvc://samba-share-claim/mymodels/build_models/mnist-onnx" diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_input_image.jpg b/Research/kubeflow-on-azure-stack-lab/04-KFServing/onnx_input_image.jpg new file mode 100644 index 0000000000000000000000000000000000000000..88e8a50a6c6cb21de5b47f5c984ad58a8b0af153 GIT binary patch literal 124814 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 z zM8WoEQ%adybzo8a1B;elDXX)N{()EM#}dT%yO6fZzx7TVMU80~Icm$@jM}=hkH{dp z&%)t=L1iv0(L z0j$?eHk8y`!-XHHM((ZUnRhU_VXL7X0fPY|fx;2y@Ymg?(I&Lhu?>3Zvg-7w;5h`K;GPzZq? z7rRyPLk2>qG>mQpmhy!42z^HHlYL$_RMUr0Gf>8I@zrp=2O^7N^Jv}3H#-OA?S)aoBH#RN{1 zv}Nu(Ch$xJ?*b%rIYK#e!7N0huc7<}-^8qHZTvQY*(X*xf06<-l3q|WpIGnFM@ts2 zy{Q2W_dk_K`Ejy$dkyAmM&Gg8CnfQc)KoOJLlVJkP&wr(X2IzlrmznY9f4~D%_=E( z=$Znp6?fU)LGzX~_&@d-HpnejrhXz$u8v|p(HXRZogJ$)S}5tctEht+bH8^V5b2}l z@M2QL&}f>xfNWyV6@8teR>S+7K!9?=4$Xwa1k7tj_Uen3>ljq2NUL}20k9mAI6-|- zI9Nh|S}TG(OW1sA#y*9L9%;{+qB` z_x+*|Z=-Colm@J>Qy&t$)_m#tl?H?1{>^sXPkBhn;lLKayQlL@^Q8n^jS6*(#o`cx zhoXaNt_Z3bjJbuf>+aLrMp#fd?M#jhZ zA%j+vkzdwB3|qi6GP=r&UAqZC2zCLtm$5RerP{``YJ&}-7%O3lL;`-{-Xis+)Mh5o zBNXc?!*C#EkdC7z8{!b(tB))eL4%pAd8T}8`~45-10u%^J1i_+HkH4!aMbhngc<>( z9HOVc{$WJPT^(S64UUhY4@!yZ%EG03I?wYP8rGE5pk%jP%d~I2u+zQiR~Le-+AmhE zEuls_5MYXdjN&2IqvyAnzLe8IGbS918Rjx;JJst@yu!kutXG+qEZ3<3Rs#8&GP*;W zm@OBf6N1#rXt=Dng(|JFUqz_){{XV5(9?jpyQFPgmBpkGjyXkX)hipPf4$9X zkn_C1XvQt70bN`&_o3J(S~BexKNT&=LUm|g5S{(^y#au{!Gx^wW9909L#D0|B4#UL z2IqMDKwuSwW+V5H@gDPvDpViBmiPP4(`U8tB2zHkzr<5-%uO2y%Pb0mT1%w0iw7b1 zOSOcoM2zLZ>8+5BtO|?bX^aNS<_aqzAm6RF`AVbYdB-GXdmXYCVUOL3yNEP2OWnQ2 z5RbiSx@6*8Xg95UHTPl33i+-@%RxMKWZ$xnGD|#t)_I43H-^TYOid>U%F1|PLwT2M z={D&g-XDH4XnO4lxipqJL3}tJhX!YA;oetbMR)%IZC%KJLnib7CHM`NVB%*F+O55h6@@7EM_FcU;N%VCd8l#pyqaa_%3 zA5rK-`T&iUB&8geB+gY#ImX^d#53#d7nn4CnQjm8J23!EkMOx|?Kp2PW={d!lxj*; zZ%%G4&AkL#`$WG&I83XpD$p=+mgeIgA|SQArsAb_1a{KuS9s)e0-(TzR60wsFC@1k zhNTmzYZOgGCCXoBDt$$5FwgyhJY$Kl&2froO2xDDG#!`&s>gTu3FC0w!MRlOfX5`8 zt%BI>54AGzpK>wKQ)bWUh@o1xIhpO9PRCY1ZHq&n)?g->ki%oq487n=(8aX4lyO)- zPf-1LY4(g`JGK0vq{BfDW|?OmKI9-eoZ4c!b(4FtxmTC8{96 z<Hk!-~tJYh1 zaLzE{^apoQG-XB+%&W^dP;Gco8G2M8Dw@T-GiaGvA~s5wk<4&5aC%C=wm83{%71#W zJ-0S{edSw^SiGZCKqbrT1`|^bS)Ss@JxuA=6mG9Ko#AJ0(aL=oX^%>&{{UMU#g}$J zmRZIS4d$DQcx?!0Z7ZZ}0XB*q63FQ_qAp)a59rg4XltVu&42Hk`$gAx1813UzI%9; z=~)xFxW9vbz2ynx>lUFjTDEo4E-+ioN)4Ka-UakcG&Vvw1UMT^OL~^*5yRcyeh26< z^=iY7iF@a3h}pMR;8b2JRw?L9Z5_F1UelcXv{GPeT&7)kG=ah>an=+cQ)yyl`xqLD z1E}#F(mv5m{h}ac%`m|lGrySnhCeHLt=Xo%6p9w;M6up1#H!VZ#P@>N9KtZ(4)VRk zu;}0tty6HjPS#wB^*^H6La*so^2^@DLb@BDDrhE%4X-3aQfcj(?|z-RPie=Y`|_k? z7&7-Ws25y$xDaKICH9_V-eMAm?ABJW)tAD!Jt&9tej(6Gj$H(%=8UuLS?g7qk76Al zy>uw^!~q)_U(W|3km zYDF~i<#8k(@eRH!ycEVri^MOpzDO_+D0*j(vQHF4w}q!jhSO+h69jx~1#sQr@nySQ>2%Fih4;$-lb?&*rZ z)@^Lz_?ye-H=sM2g3|&$i7QTYW(%styQY+`#4f2-E>UZep+ySXr3*CPVcZa%)hM|4 z*)82Wjxe6lHhmOv7?jO5BUOu2dMZ?C?I@bRI2}y1jJ~zoq;Atvp#brTTAtD2d&Xau zCC6r@tG)3RmaL6xN`5KE0cF7cn%Bg$bMgB{TsLeV6A)eE*bVCQBMs(iU)A0Sj2*{H z=M%HsKZ7?NfwS=w$74*cyu*~a>xNT=Usn4{)F1m$XVs&&D;vPCz4`;tm^WM#9t0i0n%!(gMc>yG z4Be?9F6%l86^y$1opHy!q#W-MR>eN^73MqiEddnu1+O@XE(F6;n8STu`o3nm0ERNM z@apG?6zc250yUO!)tazdnN54O78YAy5EfdP?-6z@?j<{DYT{68+{|>+CpsP=sCjAy z(Oqu~pdTr=%HIQtwcj_rZ!rBz5cfimJq9|4%v9$x5ZdKtc|fmNcwbm3FEJ?w?g>S= zToWMpnT4`CzY?6kd~31Neb&CHTo42R8z1+e-%JU+81QRzh1C+j1w`(n~eDnG0qfAm%j?|g0+G7s24$oK=;DL4iC2v`W zGH`?2o5Na>-oF0;ArEN&_r9zj16Q4 zT`*u}&#{_AJwzd2As*wljI@~Vc2;6Ks36z=KECmpQVl(OVy#v}Y2YXxs^37iQ4ukY z`$$i3K2oJcp)kljXIZ8AdJz6A2)c}5d)nRZ=>P<5fAj=Qf`D%Kja`^s`k%xs&bVpT z?qXNOaPr4>)@(UPWKgF2CQxff#Jb@g=)=M}4q*LkQ0?sr>OL>Ls)CQ{^7QdK*y3r@ zyUkkVh#WGxm%?ij?t3K6yD@R>fG*ft4s$QDD+$tGyGt(8@dj81c#z#0tb0INr~{R3 zmAes74y4~ol|v4*R<{o@T@Mv5HgrDtE_=GoPeg_#Ozj#LW>F_CO_DT&Ya$V{0+L>Y zU`}ta)@YP>Pa|;ssOIHDR}cJMr$Xm-M{u8BBZ=w}o8##(5dQ$8rkVcNwBV!t&Y#M% zv;I3{42-&1)s&8%*7qxk?*xWBICz6nx1>5^XlpQ<;X$Okrdabg>VG!MzE(93@dvOr zY#S2UspZ)t@sZjeFm24lLsuN{5q@DF4*vj@>O-QKuMj1$l)vx)0Ez-7j?80{JNr6+ z<{h%$fe78OZMEy$5OBog-f99KcOmF1rMc)f<|~m&jREqN9cnvU2o}044&C7@BUCh( zI+v#I(z|=$fE1nG`cX7nC@JkO?zHZBE@l?Jdd=2$7-0AEy=<2Ce!onWV~lH4-3jXauMI7Mhig2;$DP%o&v$rg1Qh@Jjbj zrnjVk#<2m-L&0Ozo9FF#e^&uqhW%X$)KIPB4%RQXS;O2ys%kDXsMhj<%~7n^HFuZk zq`7kexhtz0#QRD@S9{c{wm2sH9O{T>JaH;i0@}ndPprj>ndK8JL2$Snbjf&GQYs!vkdLS2ybz!~XyngH9tfg(;fmAFMR6 zVBqLatZ%OHTm?JexN#gz)~T%0{XUF!ab|pdbAs|rIJ#zmRt~Rl5ImN>pFj(vU*e5|wRV@AOcMdSs{+C5H|q<;JF>iLp}Els zfWoWMG*1!Pa3-dH-%;qsQC)6?Ow*}73Y6K124ckNn6$j``g@V`#8Vo|I}>v6ym*eE z^}p&7ZQG-(taLdEpYa(oUh6NWyPr{g6!vY4mV!4GhzHXx^YzBPaeX7-L?ubiuH53E(xYH{Ls)+3(g3to@AK7sFXQPMr;nE-k8Kq6SdDSrE;cq8u! z;CVLwf09>~9_^A(2b2_n9&W?20<*1c&Zp@RuJue4=FPB~+{$H|l&j2F(U!T@vGP3_ z^^~6StL7fx%0hQRk3?ddwM?!QR%o@n!K-Tgyq!qKq0rHp)3l+rNj*hBZ zd%IKAf<nizXgCpp*WB$a$5VGTn@gxSGO&QV4D%>2 z3-kRuOpRmrpK$JNdT;vH1c9wf0hOs{t}6Ngm|W?!>hoSAcmtwfz`-_SqF}(iJ-ZRD5ExY{#%td2Kqi(U=odwO_vu*oC0xpA=Uc1tJ3~pdOC!H@w z!-(D;NZgy(-UWMH7&}Y6XMIwzc89pQ3GYiy;&QO$n2XW^q1yxR4Q7oQu)&!AQV}`~ zoK0h~g_o%+Y&9hXIq56~C{Nl;%nD9wR+na55Dl-LF4DCov(breoZWtU%Dt&!p3Hqch{tj*AKzca%DUdn0>B?kIe-g?uHBuX%^nlipU9 zr=TjE{^A3eERK-R-f;9kqC`z!#6;NTtP0&-py1W9MziDDtwC(-#Hm*u`cx_*zOwyo zq_JcI`fP8Wr!9-F#kOu4#7 zcSL*QVXMJ*GXDTDjKB|%S4IXp59Qpgj0RZJ4zS$Iy8R^w8bfC>-s*^hRu3>tXcg(6 zUOAqp=`iMJ+T-a1hzf_q+^1=_Q*ELfTy8bd3()k^OZ1x_#L$={qH>l!>i&PH*7oXu z%7^A6TCyi%GOnoDjNAyoZ@jw$USQX&JVC(UDQdV^G(F*}t1yziS*OcuJ_exD*0>QR zH`w23uu~R$QX$)<&~K_NCU{0Umqq0SKWmJ`O%qZ&3kQ+7diGgf1i~~mnhSPZ&y5rn zqWs(uMFH~~v9S8Y0@`mEiAcKf%ygO1nPYu)V|GIxAOSoxI}wE%u;*j%6;i&ks??oi z_?bI;Lb1-jnO9wiW|q-R4H!Srb1i7B;+T5X#$ci^`4KaI{4vPwXS0 z{oXLZ;FohD!LW+7PK>3PQ8E1Tc$L_P#wzdE`abE!adYMgX*029Pf>EojoK99bs=O~ zY#>Kpu`!D45M1r|OAfrfpwcDHjGeZCr<|osC=&q|a;jy(#&{D3K7mnf&|?gv42cpd zfizRS;VvH2o1&}wO*f%xsE@z#L+pUVg&(q@)tm1Y7b{6)ePC_>00Lij9iV|?P<+3E zEYiZ6#0qjNDINsAs5owe38S>zMaYAfzj<-WLbXMpv^id2-)iPB24ETtD67yW8&HBv zG(Ij}`Ht>@!?n^XHu@p5>_L(OnC9U1@9)GQYghb=0*)Xjaqh}_PNSqole%bn)DdWu z{h-IhIgO%Ra|Fr2`yI%RfYW(d*tC0hVd|D(wjrHw;CPo!epnZt(M&5E{_Qgz$(rhW zonwMyGTfuH`IdQ4zIpzUv&7V09c5f)Z!T@`&DMU2jz~JM(o5FN3!lA4KJi+hwU_6X z9Pmm%a`$DKwG5SAuS3r<^^Yu5Z-YR~FJj<9wjka%|ewB zPo~8qtMdRaoxc0bQu5&9YYqV`evl3DX(d#xFc2x6{U#C7GPcw09jHXU!&W-tRv?92 zN!Bou-X(bNGI0?lf$JM(1sLZW>2pS5{9+d7C0f~sS$F70>4N_N7zSFR#KqG}kHUQ* z?|C7CYcKc2By>E=0NsP}9N%)!Fuc`&e8OsLRn{S>&`Yh=hr9;inQevu9ZP~giesSL zhx0p8hD{d^yv921IOIoMP8DPET&i5|y+vwLs-BYqUk&JPyV@M9Y zdXTNT;Gfz3L#(E07OaJDc$u_GdJWS=b~^nXGLLpAemn_f?Ebx_^x^Jm3g@rHO_^S1 zl4-=MJA>JPuT8vkm-CkO->gyl(JNYoM>aDvc=T%8YI`rk`dKLRIK)!?$Y-KDr-MRPhQ0{d(?7xtO6YYVSk-(@1hG?7X<8bvs{k9?4hOWjw`q># zfn!WBuO#Y61jugKb(JCi09k$zd7+PjRk~K<8*6f$vH5?=eU~wvE19clf8?$hqZxLH z53F@9YyQTs(aa5HW8QOAJb{^q68cPWt=;9AYBdpeN3vc1>l920cihgqu|iRKxm91;n? z47W%R0(NlSu=>r|Q|l{!qH>x;q`G$5QXWD*B zt?ibh+78nxguX@&uGrQNH3_!5ooDFYXC_IBy)q`+OP?2VT3GasYgF56mf2eu{0U4AAT8pmU-FxnNdG;G&ilC3$4 z=MVb+^C_`0DgtO`h!2#^8aQwFGPP~~Pu_UUNs^VN%2;-w(lVMHjN7+=?5*QT(J=2X zSg{$Y(2ih_d<z3t^g|sYXnbqyGRWP{?B|8+Qa1tqEpgy=j$phIseu4?yL}`!Mgk z0(y#)pye|C>_4Y-7qya^^|h7n1*8o<_>NRADv@!&SSVEJOmzv7ZhCDi(xJ;Up6@KE z7VJ>;U{N(;*Q;fn^%zH)aWSNOa)`y<%x&@8HdtpV*Dv`8uOlNecbC=Qj6BepS7xrVxEG$G? z{kW8#1;d70;>;$~n+!jM%7sr0M43mZc$AgD4-J@VnB>|WI?d>A4^8GIFHrj-RmC%G z#qBV(dNr)QVex;ncWJ=VYn;r6AKlNRuNm_+%d|?cmcFi$R{ceei7^o8n8YnwBVJc2 zXU3AI4kq>;&e2lM=XCBnPw@_gx1e!=9`RvigZIDcY`>OQ6=PogrWZr3H2%xRggIHv)SnGBo4%*fz6J-@ zAvtL3=q}>*y=7xqYt)+Qy|DaLA8G4Rv2Y*qYb<5w7{pq=Px1&0V9VT6By}a4 zkn}j$l0WVo%MoI-F3><`stWE*dsi}A!v6gr*xwXmy3oIy`p>gCtlBMRR|=&(1X`o| zVkmGYz&(5B-zmkoi;7L}NqS?dCj}I7e=?J_PE(re+F!@(d4?B+VS2g=7oZ4DfK z=VNEIrrFBM;cm3*#Z+iO<$*+58?^Hs9`C&9RLn2x7Hswxx9!45T!hZIPo!f;OA)m8 zd)#VlV)usD!E4dh5_cb%(sq>V2Kz#u(vSUcbYtI%=e7k$_)c+sOC{I8W?;rPG~Jnr z;cutj0%|aCo>=<3WwqRyT913j`!Odl9rmf60go3LBv3S)$mebny)U;%>R4nOQIUL>B%Wq4r@WuIC>f zuMi-VXu`S{Ea_7~#J>6`$I?@5+2$@(S9WUc9Yjp{BM|4N$x^(O-m?`N-ElUtos(Z~ zYK4d8_L!h=ukhkJS$2C(o8DkL^p2?Yp7Hw4_j%;>(f61C0I&rmk!LT9a$b9aD|7Tp zUa+uS95XR9*{~R3^reKQHMyIpG3A9|z!;h7>C?CQg~`=hiAp*}=?1lFUPG9*o}u|W z5e?gA4N=pCpi$UEr<;7u@#~!$(Yc=~9#8TSmreA|d%*}Y@Zg0|s``^A0sFmg_%Lks zus_9IW}pC$A4N;-nx3k?R}k5+Kx|6*oMU)F%)R)O{+&`Lu>&s=(2GO{VAX7n1s%jD zBaJXhNZQ|Mdm4(cGB?aM74osSGm>4{b-iI48z=|)1_j*JVRc+(SYamE`&vqISk)}H zNqb<#t;|IEUZ;c~cVyOinhW$SF_P9fls}Ut=3(1x#Jg4FmBe(G!%K<;1_Nl=0LG+6MAMcb zyl2$`iDJt_>k6DOiqX^ty=Ffikkgr~u=M1C=dhc1Hh=SJ=}WEs8$Fu+LDm}pVOTVB zx^Zkhk$E;el9W}qh-ST*Z_o`Sv}ClYL6tykF6Dh<(7>8PS7V517^!moR#%T6vX$NM zF^XImH;b%FM2ngsIvl3`i1bK**xBk$#t}*TQRPUnH1zd)#qHJ~tWd0N%xeZt(1klM znQg_y0UAD+RrCR)w7GDMnq)a4b)JS3%8Lncc!CS$aVe3JlqJ8u`;zBkxs-E{vG$au z;ti7}8^QpOWttE!JIqaiePt`TeO$u}+%w);tqVcSZSOC$F|(Ec!Y&OaQG-Fx zppY3@dLye*um!GRwN<^wnW3KWLq~|+E-WnL!d)Rc%9;r&}fDztn@Nq7-a7`Qh%RWOfTHjJ2 z*qkA&8k$F;T{^6|Cfk~&IBUuYbGqf%s~LhYe2I@l8dij{u%~h|XLz|qHNB%Xt{$-& zpHAMf#9|zEG+^Aha^=gHFVXEuR;xELyaZ0DcKS<0fGe9%6BzVEPcnx~Up`_V6lMmM z`HQp|(AaR8mM2Z1k->n$dL8ChTvqKeva|xH4a@xpS1otcYjRfI_Lr+(We}~f;DE3G z1jJU8Irw>b8yp+T~<0LruicQ?1c@O}*M$s(1b1G;f^< z95Q^$N&OLAx-flH;2T(;%|f-(T<+}q%Yl$f4A`wY?lVb^msUR(0`IF+qqMJxl)94h zUYBxJn~LYePFb!D?*wq3xn4 z%xxaWd2se2+OsHGSs~7n+RJ=LbyT^WIiYn6DOZk?jM>w<9r9(;;ZEvE{E^8lV+%ho z)*8n_E^4nvkeVOVnM~=$!R<2E{C=rdTzGWAa1!Qk|&a7is?KgeifOWoM zZnTu_@ZHw7Y_Xv1(rbK2uyIDIHiMDdmbD7t%mZnx!wMi5(q2~jb9<26TX6eC*f`{@ zfcq<{@ePX&DrM*FEEYLSt?au@Ov{RJXn)DXDk{bhw`h&kvSi_wG}d80oOhV%PEphRghvKZ!)0cZRGD5Ll7P7^hKb`iofqOuN-68;&baI z()>c{S_@j1Ws9;MJP7@g`RI5fIe8Sq0mkom)n!MI5J7@37gHXttQLB609qqz7JTYL zTG}|p*4$v0>soEBx4`{s|UiYj3woM2|he@Z& zpv+eSDZ=5&YQ`d3G(PMla(@ve+pD`Rh63Q5&1-u>%vm4Yj@@>S+$@wLP z%00xg2NU`tz;SrBi&aXR{7cH}8xa2BbbwY*w-;V_L3fLkWey@zYok$U7fDSYFo!Rp z1?V>m8)NS%qqwQJ>k+PX9F6OlK*F8?u901)yRIBRSXv1A38D&z0pc80s&h0^gKFMi zO|@AoF8nUcMf<2O8kmOnvdv8xws#8i!78I==GW{)dB!7k(@RWand~ktIe&>Qr^AMd7X2rm+qUo z*&Xqg3^yj-dqx`#6S^we`Siamc$9aDH10~hN;G6nMjPu{UI|L+#=6C!`%@m3kGDPJ z1C!YcGKG0UdetOc7W=%dCJjR{>>9$Y)~M&PF(Y=M{71LMK@3V@W_P)Txi6@Kzk(*u zm{{5GlYS#xWSRJfpy(os+d!Ou$j6|taZ7GWEFLwAGm{uKIxvP=Q>@SEgs!|%!Mg^w zzFbREw@P-*7T8(Pts)(1QQj)$v9{OiGfk^J9f@~~b$mq3XY07B6NTNn%{qnf*{>B7 z^w>F?_~pB|-5W6l80f_-ke^TTT2pma+rp%VMF1bX8;<_uTutcd09~xDDenVld<^f# zuuMfty5bnx(a;Z?kFR=e1HX>#eqqP2FGh^X`j&2;n3*&FPUOUrq*SQ?rw7V_J)2^%uYcNW;gx|hnu2Zj9Gc_L-!!_)W zXnt;`8rTO`&<->`;^PHQgZ|2e7Cc_vk~a8khnkM1lKezZHoq{x#2dgL^HacVfs6px ziGHrdUeT_vS(wo^xsNe5seSqtfnGKQi2kl)B$oVX|b_py|qEk1-LVs{2M1 za|&syKbCrVo%uFx%%~6$DQtnAWIiI2>13(N17SZXPjWZf`t2yv_TO;$CI%17#nLA_`=siq&> zW(T&0@bE^3;*i>ERvuDF)^#`DTy_gH_U-iAFLtT~98OBK6ESArFXA1JeQzR~LJZghp1Yj+RK zEsSy67#X6?6g7Eo#MV~gyx#HloQZkz{?Guy<{%9{1O*I`_PA-phrDs_arn5-;QFD1 z>cQaDIv=DntTWh|h^fNt%GUQjCYOxtqKyKjp3lxMa&AhivkTU)q72m($8I%raDvpS z4ZfcW8^6CU8aa2CtioO1*qinkC+_PU>B!82<*$|+TTusER`w?J{evrw3Gz&^F5v3Q z=To=VrS@P~E3C*>_07xb#eH^s%*xsEjcITo`$8JFI@&#$=X@diakAX)lz@S=UvTp@ z+V6NewFfWGFA9xyl5xaLP9HFR2Kg(?^8;aUXn8kxmcjDI6mtd!-8m(9r&|Ww{iPVz z1!*ZpjBd73rmgx{4Xz$tLg{Yd7RkKww|bl(E!yj*k*F1&BPlZe_kZ1#xSgBvra?qN4P=C3a&Ntk)M zfzxD41*_*ZXP@=}STc@k9eO->HDqf|TO{{Utko(EHyc7m&F98{~<9tL))FK89pwbiIf<0kbJW?2L}9+wrE+OXZi zJ3lG6`<+rbwJ@}uZM>KaO~Sk?OGRqK{M zpxbk10os=f;_iIMnAAXz6d(#*9%YK-p_OfekMt+>p)<>eaR%(RV2u)1ZAj*v|r zrxMWhCaiv(LV0~7-QoC*%nfd@7T&tSK9X+$^RdsN`FslQif==P4CLYTQU1#FdhE@5xC~GnMRr- ztlBifsJLP^RA7{=hq5ZeF&?R9O;>orVrGo2FG|Jx8ytR5?8bPei=QKr_H*Bqq z90Xf-PD<6{vGT#yK{jF|o-ed3n_CFpm9x2Z8yZpN@6^qzU{SqJn{T`^F&dT1;xQKt z?bx{vUEvW*`xk!@T-bTJvyG;#oo-gw%)dcPjL?0=RQBu~i&hR(z9TyS0Cb=OG;iJq(ZDN+s0!TqOEntGFrCWZZXo�bv|I(SV`t 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 p#LZ`P;@ Date: Thu, 22 Oct 2020 10:06:32 -0700 Subject: [PATCH 4/4] adding auto-generated protobyf assets for onnx model --- .../04-KFServing/assets/onnx_ml_pb2.py | 1581 +++++++++++++++++ .../04-KFServing/assets/predict_pb2.py | 215 +++ 2 files changed, 1796 insertions(+) create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/onnx_ml_pb2.py create mode 100644 Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/predict_pb2.py diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/onnx_ml_pb2.py b/Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/onnx_ml_pb2.py new file mode 100644 index 000000000..b7d159254 --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/onnx_ml_pb2.py @@ -0,0 +1,1581 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: onnx-ml.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='onnx-ml.proto', + package='onnx', + syntax='proto3', + serialized_options=None, + serialized_pb=_b('\n\ronnx-ml.proto\x12\x04onnx\"\xe0\x03\n\x0e\x41ttributeProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x15\n\rref_attr_name\x18\x15 \x01(\t\x12\x12\n\ndoc_string\x18\r \x01(\t\x12\x30\n\x04type\x18\x14 \x01(\x0e\x32\".onnx.AttributeProto.AttributeType\x12\t\n\x01\x66\x18\x02 \x01(\x02\x12\t\n\x01i\x18\x03 \x01(\x03\x12\t\n\x01s\x18\x04 \x01(\x0c\x12\x1c\n\x01t\x18\x05 \x01(\x0b\x32\x11.onnx.TensorProto\x12\x1b\n\x01g\x18\x06 \x01(\x0b\x32\x10.onnx.GraphProto\x12\x0e\n\x06\x66loats\x18\x07 \x03(\x02\x12\x0c\n\x04ints\x18\x08 \x03(\x03\x12\x0f\n\x07strings\x18\t \x03(\x0c\x12\"\n\x07tensors\x18\n \x03(\x0b\x32\x11.onnx.TensorProto\x12 \n\x06graphs\x18\x0b \x03(\x0b\x32\x10.onnx.GraphProto\"\x91\x01\n\rAttributeType\x12\r\n\tUNDEFINED\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\x07\n\x03INT\x10\x02\x12\n\n\x06STRING\x10\x03\x12\n\n\x06TENSOR\x10\x04\x12\t\n\x05GRAPH\x10\x05\x12\n\n\x06\x46LOATS\x10\x06\x12\x08\n\x04INTS\x10\x07\x12\x0b\n\x07STRINGS\x10\x08\x12\x0b\n\x07TENSORS\x10\t\x12\n\n\x06GRAPHS\x10\n\"Q\n\x0eValueInfoProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1d\n\x04type\x18\x02 \x01(\x0b\x32\x0f.onnx.TypeProto\x12\x12\n\ndoc_string\x18\x03 \x01(\t\"\x96\x01\n\tNodeProto\x12\r\n\x05input\x18\x01 \x03(\t\x12\x0e\n\x06output\x18\x02 \x03(\t\x12\x0c\n\x04name\x18\x03 \x01(\t\x12\x0f\n\x07op_type\x18\x04 \x01(\t\x12\x0e\n\x06\x64omain\x18\x07 \x01(\t\x12\'\n\tattribute\x18\x05 \x03(\x0b\x32\x14.onnx.AttributeProto\x12\x12\n\ndoc_string\x18\x06 \x01(\t\"\xbb\x02\n\nModelProto\x12\x12\n\nir_version\x18\x01 \x01(\x03\x12.\n\x0copset_import\x18\x08 \x03(\x0b\x32\x18.onnx.OperatorSetIdProto\x12\x15\n\rproducer_name\x18\x02 \x01(\t\x12\x18\n\x10producer_version\x18\x03 \x01(\t\x12\x0e\n\x06\x64omain\x18\x04 \x01(\t\x12\x15\n\rmodel_version\x18\x05 \x01(\x03\x12\x12\n\ndoc_string\x18\x06 \x01(\t\x12\x1f\n\x05graph\x18\x07 \x01(\x0b\x32\x10.onnx.GraphProto\x12&\n\tfunctions\x18\x64 \x03(\x0b\x32\x13.onnx.FunctionProto\x12\x34\n\x0emetadata_props\x18\x0e \x03(\x0b\x32\x1c.onnx.StringStringEntryProto\"4\n\x16StringStringEntryProto\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t\"k\n\x10TensorAnnotation\x12\x13\n\x0btensor_name\x18\x01 \x01(\t\x12\x42\n\x1cquant_parameter_tensor_names\x18\x02 \x03(\x0b\x32\x1c.onnx.StringStringEntryProto\"\xa3\x02\n\nGraphProto\x12\x1d\n\x04node\x18\x01 \x03(\x0b\x32\x0f.onnx.NodeProto\x12\x0c\n\x04name\x18\x02 \x01(\t\x12&\n\x0binitializer\x18\x05 \x03(\x0b\x32\x11.onnx.TensorProto\x12\x12\n\ndoc_string\x18\n \x01(\t\x12#\n\x05input\x18\x0b \x03(\x0b\x32\x14.onnx.ValueInfoProto\x12$\n\x06output\x18\x0c \x03(\x0b\x32\x14.onnx.ValueInfoProto\x12(\n\nvalue_info\x18\r \x03(\x0b\x32\x14.onnx.ValueInfoProto\x12\x37\n\x17quantization_annotation\x18\x0e \x03(\x0b\x32\x16.onnx.TensorAnnotation\"\xb8\x05\n\x0bTensorProto\x12\x0c\n\x04\x64ims\x18\x01 \x03(\x03\x12\x11\n\tdata_type\x18\x02 \x01(\x05\x12*\n\x07segment\x18\x03 \x01(\x0b\x32\x19.onnx.TensorProto.Segment\x12\x16\n\nfloat_data\x18\x04 \x03(\x02\x42\x02\x10\x01\x12\x16\n\nint32_data\x18\x05 \x03(\x05\x42\x02\x10\x01\x12\x13\n\x0bstring_data\x18\x06 \x03(\x0c\x12\x16\n\nint64_data\x18\x07 \x03(\x03\x42\x02\x10\x01\x12\x0c\n\x04name\x18\x08 \x01(\t\x12\x12\n\ndoc_string\x18\x0c \x01(\t\x12\x10\n\x08raw_data\x18\t \x01(\x0c\x12\x33\n\rexternal_data\x18\r \x03(\x0b\x32\x1c.onnx.StringStringEntryProto\x12\x35\n\rdata_location\x18\x0e \x01(\x0e\x32\x1e.onnx.TensorProto.DataLocation\x12\x17\n\x0b\x64ouble_data\x18\n \x03(\x01\x42\x02\x10\x01\x12\x17\n\x0buint64_data\x18\x0b \x03(\x04\x42\x02\x10\x01\x1a%\n\x07Segment\x12\r\n\x05\x62\x65gin\x18\x01 \x01(\x03\x12\x0b\n\x03\x65nd\x18\x02 \x01(\x03\"\xda\x01\n\x08\x44\x61taType\x12\r\n\tUNDEFINED\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\t\n\x05UINT8\x10\x02\x12\x08\n\x04INT8\x10\x03\x12\n\n\x06UINT16\x10\x04\x12\t\n\x05INT16\x10\x05\x12\t\n\x05INT32\x10\x06\x12\t\n\x05INT64\x10\x07\x12\n\n\x06STRING\x10\x08\x12\x08\n\x04\x42OOL\x10\t\x12\x0b\n\x07\x46LOAT16\x10\n\x12\n\n\x06\x44OUBLE\x10\x0b\x12\n\n\x06UINT32\x10\x0c\x12\n\n\x06UINT64\x10\r\x12\r\n\tCOMPLEX64\x10\x0e\x12\x0e\n\nCOMPLEX128\x10\x0f\x12\x0c\n\x08\x42\x46LOAT16\x10\x10\")\n\x0c\x44\x61taLocation\x12\x0b\n\x07\x44\x45\x46\x41ULT\x10\x00\x12\x0c\n\x08\x45XTERNAL\x10\x01\"\x95\x01\n\x10TensorShapeProto\x12-\n\x03\x64im\x18\x01 \x03(\x0b\x32 .onnx.TensorShapeProto.Dimension\x1aR\n\tDimension\x12\x13\n\tdim_value\x18\x01 \x01(\x03H\x00\x12\x13\n\tdim_param\x18\x02 \x01(\tH\x00\x12\x12\n\ndenotation\x18\x03 \x01(\tB\x07\n\x05value\"\xc2\x04\n\tTypeProto\x12-\n\x0btensor_type\x18\x01 \x01(\x0b\x32\x16.onnx.TypeProto.TensorH\x00\x12\x31\n\rsequence_type\x18\x04 \x01(\x0b\x32\x18.onnx.TypeProto.SequenceH\x00\x12\'\n\x08map_type\x18\x05 \x01(\x0b\x32\x13.onnx.TypeProto.MapH\x00\x12-\n\x0bopaque_type\x18\x07 \x01(\x0b\x32\x16.onnx.TypeProto.OpaqueH\x00\x12:\n\x12sparse_tensor_type\x18\x08 \x01(\x0b\x32\x1c.onnx.TypeProto.SparseTensorH\x00\x12\x12\n\ndenotation\x18\x06 \x01(\t\x1a\x42\n\x06Tensor\x12\x11\n\telem_type\x18\x01 \x01(\x05\x12%\n\x05shape\x18\x02 \x01(\x0b\x32\x16.onnx.TensorShapeProto\x1a.\n\x08Sequence\x12\"\n\telem_type\x18\x01 \x01(\x0b\x32\x0f.onnx.TypeProto\x1a<\n\x03Map\x12\x10\n\x08key_type\x18\x01 \x01(\x05\x12#\n\nvalue_type\x18\x02 \x01(\x0b\x32\x0f.onnx.TypeProto\x1a&\n\x06Opaque\x12\x0e\n\x06\x64omain\x18\x01 \x01(\t\x12\x0c\n\x04name\x18\x02 \x01(\t\x1aH\n\x0cSparseTensor\x12\x11\n\telem_type\x18\x01 \x01(\x05\x12%\n\x05shape\x18\x02 \x01(\x0b\x32\x16.onnx.TensorShapeProtoB\x07\n\x05value\"5\n\x12OperatorSetIdProto\x12\x0e\n\x06\x64omain\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\x03\"\xbf\x01\n\rFunctionProto\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x15\n\rsince_version\x18\x02 \x01(\x03\x12$\n\x06status\x18\x03 \x01(\x0e\x32\x14.onnx.OperatorStatus\x12\r\n\x05input\x18\x04 \x03(\t\x12\x0e\n\x06output\x18\x05 \x03(\t\x12\x11\n\tattribute\x18\x06 \x03(\t\x12\x1d\n\x04node\x18\x07 \x03(\x0b\x32\x0f.onnx.NodeProto\x12\x12\n\ndoc_string\x18\x08 \x01(\t*\x97\x01\n\x07Version\x12\x12\n\x0e_START_VERSION\x10\x00\x12\x19\n\x15IR_VERSION_2017_10_10\x10\x01\x12\x19\n\x15IR_VERSION_2017_10_30\x10\x02\x12\x18\n\x14IR_VERSION_2017_11_3\x10\x03\x12\x18\n\x14IR_VERSION_2019_1_22\x10\x04\x12\x0e\n\nIR_VERSION\x10\x05*.\n\x0eOperatorStatus\x12\x10\n\x0c\x45XPERIMENTAL\x10\x00\x12\n\n\x06STABLE\x10\x01\x62\x06proto3') +) + +_VERSION = _descriptor.EnumDescriptor( + name='Version', + full_name='onnx.Version', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='_START_VERSION', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IR_VERSION_2017_10_10', index=1, number=1, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IR_VERSION_2017_10_30', index=2, number=2, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IR_VERSION_2017_11_3', index=3, number=3, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IR_VERSION_2019_1_22', index=4, number=4, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='IR_VERSION', index=5, number=5, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=3199, + serialized_end=3350, +) +_sym_db.RegisterEnumDescriptor(_VERSION) + +Version = enum_type_wrapper.EnumTypeWrapper(_VERSION) +_OPERATORSTATUS = _descriptor.EnumDescriptor( + name='OperatorStatus', + full_name='onnx.OperatorStatus', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='EXPERIMENTAL', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STABLE', index=1, number=1, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=3352, + serialized_end=3398, +) +_sym_db.RegisterEnumDescriptor(_OPERATORSTATUS) + +OperatorStatus = enum_type_wrapper.EnumTypeWrapper(_OPERATORSTATUS) +_START_VERSION = 0 +IR_VERSION_2017_10_10 = 1 +IR_VERSION_2017_10_30 = 2 +IR_VERSION_2017_11_3 = 3 +IR_VERSION_2019_1_22 = 4 +IR_VERSION = 5 +EXPERIMENTAL = 0 +STABLE = 1 + + +_ATTRIBUTEPROTO_ATTRIBUTETYPE = _descriptor.EnumDescriptor( + name='AttributeType', + full_name='onnx.AttributeProto.AttributeType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNDEFINED', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FLOAT', index=1, number=1, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INT', index=2, number=2, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STRING', index=3, number=3, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='TENSOR', index=4, number=4, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='GRAPH', index=5, number=5, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FLOATS', index=6, number=6, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INTS', index=7, number=7, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STRINGS', index=8, number=8, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='TENSORS', index=9, number=9, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='GRAPHS', index=10, number=10, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=359, + serialized_end=504, +) +_sym_db.RegisterEnumDescriptor(_ATTRIBUTEPROTO_ATTRIBUTETYPE) + +_TENSORPROTO_DATATYPE = _descriptor.EnumDescriptor( + name='DataType', + full_name='onnx.TensorProto.DataType', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='UNDEFINED', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FLOAT', index=1, number=1, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UINT8', index=2, number=2, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INT8', index=3, number=3, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UINT16', index=4, number=4, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INT16', index=5, number=5, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INT32', index=6, number=6, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='INT64', index=7, number=7, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='STRING', index=8, number=8, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BOOL', index=9, number=9, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='FLOAT16', index=10, number=10, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='DOUBLE', index=11, number=11, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UINT32', index=12, number=12, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='UINT64', index=13, number=13, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='COMPLEX64', index=14, number=14, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='COMPLEX128', index=15, number=15, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='BFLOAT16', index=16, number=16, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=1953, + serialized_end=2171, +) +_sym_db.RegisterEnumDescriptor(_TENSORPROTO_DATATYPE) + +_TENSORPROTO_DATALOCATION = _descriptor.EnumDescriptor( + name='DataLocation', + full_name='onnx.TensorProto.DataLocation', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='DEFAULT', index=0, number=0, + serialized_options=None, + type=None), + _descriptor.EnumValueDescriptor( + name='EXTERNAL', index=1, number=1, + serialized_options=None, + type=None), + ], + containing_type=None, + serialized_options=None, + serialized_start=2173, + serialized_end=2214, +) +_sym_db.RegisterEnumDescriptor(_TENSORPROTO_DATALOCATION) + + +_ATTRIBUTEPROTO = _descriptor.Descriptor( + name='AttributeProto', + full_name='onnx.AttributeProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='onnx.AttributeProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='ref_attr_name', full_name='onnx.AttributeProto.ref_attr_name', index=1, + number=21, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.AttributeProto.doc_string', index=2, + number=13, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='type', full_name='onnx.AttributeProto.type', index=3, + number=20, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='f', full_name='onnx.AttributeProto.f', index=4, + number=2, type=2, cpp_type=6, label=1, + has_default_value=False, default_value=float(0), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='i', full_name='onnx.AttributeProto.i', index=5, + number=3, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='s', full_name='onnx.AttributeProto.s', index=6, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='t', full_name='onnx.AttributeProto.t', index=7, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='g', full_name='onnx.AttributeProto.g', index=8, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='floats', full_name='onnx.AttributeProto.floats', index=9, + number=7, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='ints', full_name='onnx.AttributeProto.ints', index=10, + number=8, type=3, cpp_type=2, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='strings', full_name='onnx.AttributeProto.strings', index=11, + number=9, type=12, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='tensors', full_name='onnx.AttributeProto.tensors', index=12, + number=10, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='graphs', full_name='onnx.AttributeProto.graphs', index=13, + number=11, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + _ATTRIBUTEPROTO_ATTRIBUTETYPE, + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=24, + serialized_end=504, +) + + +_VALUEINFOPROTO = _descriptor.Descriptor( + name='ValueInfoProto', + full_name='onnx.ValueInfoProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='onnx.ValueInfoProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='type', full_name='onnx.ValueInfoProto.type', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.ValueInfoProto.doc_string', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=506, + serialized_end=587, +) + + +_NODEPROTO = _descriptor.Descriptor( + name='NodeProto', + full_name='onnx.NodeProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='input', full_name='onnx.NodeProto.input', index=0, + number=1, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='output', full_name='onnx.NodeProto.output', index=1, + number=2, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='name', full_name='onnx.NodeProto.name', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='op_type', full_name='onnx.NodeProto.op_type', index=3, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='domain', full_name='onnx.NodeProto.domain', index=4, + number=7, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='attribute', full_name='onnx.NodeProto.attribute', index=5, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.NodeProto.doc_string', index=6, + number=6, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=590, + serialized_end=740, +) + + +_MODELPROTO = _descriptor.Descriptor( + name='ModelProto', + full_name='onnx.ModelProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='ir_version', full_name='onnx.ModelProto.ir_version', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='opset_import', full_name='onnx.ModelProto.opset_import', index=1, + number=8, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='producer_name', full_name='onnx.ModelProto.producer_name', index=2, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='producer_version', full_name='onnx.ModelProto.producer_version', index=3, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='domain', full_name='onnx.ModelProto.domain', index=4, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='model_version', full_name='onnx.ModelProto.model_version', index=5, + number=5, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.ModelProto.doc_string', index=6, + number=6, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='graph', full_name='onnx.ModelProto.graph', index=7, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='functions', full_name='onnx.ModelProto.functions', index=8, + number=100, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='metadata_props', full_name='onnx.ModelProto.metadata_props', index=9, + number=14, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=743, + serialized_end=1058, +) + + +_STRINGSTRINGENTRYPROTO = _descriptor.Descriptor( + name='StringStringEntryProto', + full_name='onnx.StringStringEntryProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key', full_name='onnx.StringStringEntryProto.key', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='value', full_name='onnx.StringStringEntryProto.value', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1060, + serialized_end=1112, +) + + +_TENSORANNOTATION = _descriptor.Descriptor( + name='TensorAnnotation', + full_name='onnx.TensorAnnotation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='tensor_name', full_name='onnx.TensorAnnotation.tensor_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='quant_parameter_tensor_names', full_name='onnx.TensorAnnotation.quant_parameter_tensor_names', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1114, + serialized_end=1221, +) + + +_GRAPHPROTO = _descriptor.Descriptor( + name='GraphProto', + full_name='onnx.GraphProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='node', full_name='onnx.GraphProto.node', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='name', full_name='onnx.GraphProto.name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='initializer', full_name='onnx.GraphProto.initializer', index=2, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.GraphProto.doc_string', index=3, + number=10, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='input', full_name='onnx.GraphProto.input', index=4, + number=11, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='output', full_name='onnx.GraphProto.output', index=5, + number=12, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='value_info', full_name='onnx.GraphProto.value_info', index=6, + number=13, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='quantization_annotation', full_name='onnx.GraphProto.quantization_annotation', index=7, + number=14, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1224, + serialized_end=1515, +) + + +_TENSORPROTO_SEGMENT = _descriptor.Descriptor( + name='Segment', + full_name='onnx.TensorProto.Segment', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='begin', full_name='onnx.TensorProto.Segment.begin', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='end', full_name='onnx.TensorProto.Segment.end', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1913, + serialized_end=1950, +) + +_TENSORPROTO = _descriptor.Descriptor( + name='TensorProto', + full_name='onnx.TensorProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='dims', full_name='onnx.TensorProto.dims', index=0, + number=1, type=3, cpp_type=2, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='data_type', full_name='onnx.TensorProto.data_type', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='segment', full_name='onnx.TensorProto.segment', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='float_data', full_name='onnx.TensorProto.float_data', index=3, + number=4, type=2, cpp_type=6, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=_b('\020\001'), file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='int32_data', full_name='onnx.TensorProto.int32_data', index=4, + number=5, type=5, cpp_type=1, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=_b('\020\001'), file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='string_data', full_name='onnx.TensorProto.string_data', index=5, + number=6, type=12, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='int64_data', full_name='onnx.TensorProto.int64_data', index=6, + number=7, type=3, cpp_type=2, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=_b('\020\001'), file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='name', full_name='onnx.TensorProto.name', index=7, + number=8, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.TensorProto.doc_string', index=8, + number=12, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='raw_data', full_name='onnx.TensorProto.raw_data', index=9, + number=9, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='external_data', full_name='onnx.TensorProto.external_data', index=10, + number=13, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='data_location', full_name='onnx.TensorProto.data_location', index=11, + number=14, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='double_data', full_name='onnx.TensorProto.double_data', index=12, + number=10, type=1, cpp_type=5, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=_b('\020\001'), file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='uint64_data', full_name='onnx.TensorProto.uint64_data', index=13, + number=11, type=4, cpp_type=4, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=_b('\020\001'), file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[_TENSORPROTO_SEGMENT, ], + enum_types=[ + _TENSORPROTO_DATATYPE, + _TENSORPROTO_DATALOCATION, + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1518, + serialized_end=2214, +) + + +_TENSORSHAPEPROTO_DIMENSION = _descriptor.Descriptor( + name='Dimension', + full_name='onnx.TensorShapeProto.Dimension', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='dim_value', full_name='onnx.TensorShapeProto.Dimension.dim_value', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='dim_param', full_name='onnx.TensorShapeProto.Dimension.dim_param', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='denotation', full_name='onnx.TensorShapeProto.Dimension.denotation', index=2, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='value', full_name='onnx.TensorShapeProto.Dimension.value', + index=0, containing_type=None, fields=[]), + ], + serialized_start=2284, + serialized_end=2366, +) + +_TENSORSHAPEPROTO = _descriptor.Descriptor( + name='TensorShapeProto', + full_name='onnx.TensorShapeProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='dim', full_name='onnx.TensorShapeProto.dim', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[_TENSORSHAPEPROTO_DIMENSION, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2217, + serialized_end=2366, +) + + +_TYPEPROTO_TENSOR = _descriptor.Descriptor( + name='Tensor', + full_name='onnx.TypeProto.Tensor', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='elem_type', full_name='onnx.TypeProto.Tensor.elem_type', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='shape', full_name='onnx.TypeProto.Tensor.shape', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2648, + serialized_end=2714, +) + +_TYPEPROTO_SEQUENCE = _descriptor.Descriptor( + name='Sequence', + full_name='onnx.TypeProto.Sequence', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='elem_type', full_name='onnx.TypeProto.Sequence.elem_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2716, + serialized_end=2762, +) + +_TYPEPROTO_MAP = _descriptor.Descriptor( + name='Map', + full_name='onnx.TypeProto.Map', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key_type', full_name='onnx.TypeProto.Map.key_type', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='value_type', full_name='onnx.TypeProto.Map.value_type', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2764, + serialized_end=2824, +) + +_TYPEPROTO_OPAQUE = _descriptor.Descriptor( + name='Opaque', + full_name='onnx.TypeProto.Opaque', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='domain', full_name='onnx.TypeProto.Opaque.domain', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='name', full_name='onnx.TypeProto.Opaque.name', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2826, + serialized_end=2864, +) + +_TYPEPROTO_SPARSETENSOR = _descriptor.Descriptor( + name='SparseTensor', + full_name='onnx.TypeProto.SparseTensor', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='elem_type', full_name='onnx.TypeProto.SparseTensor.elem_type', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='shape', full_name='onnx.TypeProto.SparseTensor.shape', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2866, + serialized_end=2938, +) + +_TYPEPROTO = _descriptor.Descriptor( + name='TypeProto', + full_name='onnx.TypeProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='tensor_type', full_name='onnx.TypeProto.tensor_type', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='sequence_type', full_name='onnx.TypeProto.sequence_type', index=1, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='map_type', full_name='onnx.TypeProto.map_type', index=2, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='opaque_type', full_name='onnx.TypeProto.opaque_type', index=3, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='sparse_tensor_type', full_name='onnx.TypeProto.sparse_tensor_type', index=4, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='denotation', full_name='onnx.TypeProto.denotation', index=5, + number=6, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[_TYPEPROTO_TENSOR, _TYPEPROTO_SEQUENCE, _TYPEPROTO_MAP, _TYPEPROTO_OPAQUE, _TYPEPROTO_SPARSETENSOR, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='value', full_name='onnx.TypeProto.value', + index=0, containing_type=None, fields=[]), + ], + serialized_start=2369, + serialized_end=2947, +) + + +_OPERATORSETIDPROTO = _descriptor.Descriptor( + name='OperatorSetIdProto', + full_name='onnx.OperatorSetIdProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='domain', full_name='onnx.OperatorSetIdProto.domain', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='version', full_name='onnx.OperatorSetIdProto.version', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2949, + serialized_end=3002, +) + + +_FUNCTIONPROTO = _descriptor.Descriptor( + name='FunctionProto', + full_name='onnx.FunctionProto', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='onnx.FunctionProto.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='since_version', full_name='onnx.FunctionProto.since_version', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='status', full_name='onnx.FunctionProto.status', index=2, + number=3, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='input', full_name='onnx.FunctionProto.input', index=3, + number=4, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='output', full_name='onnx.FunctionProto.output', index=4, + number=5, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='attribute', full_name='onnx.FunctionProto.attribute', index=5, + number=6, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='node', full_name='onnx.FunctionProto.node', index=6, + number=7, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='doc_string', full_name='onnx.FunctionProto.doc_string', index=7, + number=8, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=3005, + serialized_end=3196, +) + +_ATTRIBUTEPROTO.fields_by_name['type'].enum_type = _ATTRIBUTEPROTO_ATTRIBUTETYPE +_ATTRIBUTEPROTO.fields_by_name['t'].message_type = _TENSORPROTO +_ATTRIBUTEPROTO.fields_by_name['g'].message_type = _GRAPHPROTO +_ATTRIBUTEPROTO.fields_by_name['tensors'].message_type = _TENSORPROTO +_ATTRIBUTEPROTO.fields_by_name['graphs'].message_type = _GRAPHPROTO +_ATTRIBUTEPROTO_ATTRIBUTETYPE.containing_type = _ATTRIBUTEPROTO +_VALUEINFOPROTO.fields_by_name['type'].message_type = _TYPEPROTO +_NODEPROTO.fields_by_name['attribute'].message_type = _ATTRIBUTEPROTO +_MODELPROTO.fields_by_name['opset_import'].message_type = _OPERATORSETIDPROTO +_MODELPROTO.fields_by_name['graph'].message_type = _GRAPHPROTO +_MODELPROTO.fields_by_name['functions'].message_type = _FUNCTIONPROTO +_MODELPROTO.fields_by_name['metadata_props'].message_type = _STRINGSTRINGENTRYPROTO +_TENSORANNOTATION.fields_by_name['quant_parameter_tensor_names'].message_type = _STRINGSTRINGENTRYPROTO +_GRAPHPROTO.fields_by_name['node'].message_type = _NODEPROTO +_GRAPHPROTO.fields_by_name['initializer'].message_type = _TENSORPROTO +_GRAPHPROTO.fields_by_name['input'].message_type = _VALUEINFOPROTO +_GRAPHPROTO.fields_by_name['output'].message_type = _VALUEINFOPROTO +_GRAPHPROTO.fields_by_name['value_info'].message_type = _VALUEINFOPROTO +_GRAPHPROTO.fields_by_name['quantization_annotation'].message_type = _TENSORANNOTATION +_TENSORPROTO_SEGMENT.containing_type = _TENSORPROTO +_TENSORPROTO.fields_by_name['segment'].message_type = _TENSORPROTO_SEGMENT +_TENSORPROTO.fields_by_name['external_data'].message_type = _STRINGSTRINGENTRYPROTO +_TENSORPROTO.fields_by_name['data_location'].enum_type = _TENSORPROTO_DATALOCATION +_TENSORPROTO_DATATYPE.containing_type = _TENSORPROTO +_TENSORPROTO_DATALOCATION.containing_type = _TENSORPROTO +_TENSORSHAPEPROTO_DIMENSION.containing_type = _TENSORSHAPEPROTO +_TENSORSHAPEPROTO_DIMENSION.oneofs_by_name['value'].fields.append( + _TENSORSHAPEPROTO_DIMENSION.fields_by_name['dim_value']) +_TENSORSHAPEPROTO_DIMENSION.fields_by_name['dim_value'].containing_oneof = _TENSORSHAPEPROTO_DIMENSION.oneofs_by_name['value'] +_TENSORSHAPEPROTO_DIMENSION.oneofs_by_name['value'].fields.append( + _TENSORSHAPEPROTO_DIMENSION.fields_by_name['dim_param']) +_TENSORSHAPEPROTO_DIMENSION.fields_by_name['dim_param'].containing_oneof = _TENSORSHAPEPROTO_DIMENSION.oneofs_by_name['value'] +_TENSORSHAPEPROTO.fields_by_name['dim'].message_type = _TENSORSHAPEPROTO_DIMENSION +_TYPEPROTO_TENSOR.fields_by_name['shape'].message_type = _TENSORSHAPEPROTO +_TYPEPROTO_TENSOR.containing_type = _TYPEPROTO +_TYPEPROTO_SEQUENCE.fields_by_name['elem_type'].message_type = _TYPEPROTO +_TYPEPROTO_SEQUENCE.containing_type = _TYPEPROTO +_TYPEPROTO_MAP.fields_by_name['value_type'].message_type = _TYPEPROTO +_TYPEPROTO_MAP.containing_type = _TYPEPROTO +_TYPEPROTO_OPAQUE.containing_type = _TYPEPROTO +_TYPEPROTO_SPARSETENSOR.fields_by_name['shape'].message_type = _TENSORSHAPEPROTO +_TYPEPROTO_SPARSETENSOR.containing_type = _TYPEPROTO +_TYPEPROTO.fields_by_name['tensor_type'].message_type = _TYPEPROTO_TENSOR +_TYPEPROTO.fields_by_name['sequence_type'].message_type = _TYPEPROTO_SEQUENCE +_TYPEPROTO.fields_by_name['map_type'].message_type = _TYPEPROTO_MAP +_TYPEPROTO.fields_by_name['opaque_type'].message_type = _TYPEPROTO_OPAQUE +_TYPEPROTO.fields_by_name['sparse_tensor_type'].message_type = _TYPEPROTO_SPARSETENSOR +_TYPEPROTO.oneofs_by_name['value'].fields.append( + _TYPEPROTO.fields_by_name['tensor_type']) +_TYPEPROTO.fields_by_name['tensor_type'].containing_oneof = _TYPEPROTO.oneofs_by_name['value'] +_TYPEPROTO.oneofs_by_name['value'].fields.append( + _TYPEPROTO.fields_by_name['sequence_type']) +_TYPEPROTO.fields_by_name['sequence_type'].containing_oneof = _TYPEPROTO.oneofs_by_name['value'] +_TYPEPROTO.oneofs_by_name['value'].fields.append( + _TYPEPROTO.fields_by_name['map_type']) +_TYPEPROTO.fields_by_name['map_type'].containing_oneof = _TYPEPROTO.oneofs_by_name['value'] +_TYPEPROTO.oneofs_by_name['value'].fields.append( + _TYPEPROTO.fields_by_name['opaque_type']) +_TYPEPROTO.fields_by_name['opaque_type'].containing_oneof = _TYPEPROTO.oneofs_by_name['value'] +_TYPEPROTO.oneofs_by_name['value'].fields.append( + _TYPEPROTO.fields_by_name['sparse_tensor_type']) +_TYPEPROTO.fields_by_name['sparse_tensor_type'].containing_oneof = _TYPEPROTO.oneofs_by_name['value'] +_FUNCTIONPROTO.fields_by_name['status'].enum_type = _OPERATORSTATUS +_FUNCTIONPROTO.fields_by_name['node'].message_type = _NODEPROTO +DESCRIPTOR.message_types_by_name['AttributeProto'] = _ATTRIBUTEPROTO +DESCRIPTOR.message_types_by_name['ValueInfoProto'] = _VALUEINFOPROTO +DESCRIPTOR.message_types_by_name['NodeProto'] = _NODEPROTO +DESCRIPTOR.message_types_by_name['ModelProto'] = _MODELPROTO +DESCRIPTOR.message_types_by_name['StringStringEntryProto'] = _STRINGSTRINGENTRYPROTO +DESCRIPTOR.message_types_by_name['TensorAnnotation'] = _TENSORANNOTATION +DESCRIPTOR.message_types_by_name['GraphProto'] = _GRAPHPROTO +DESCRIPTOR.message_types_by_name['TensorProto'] = _TENSORPROTO +DESCRIPTOR.message_types_by_name['TensorShapeProto'] = _TENSORSHAPEPROTO +DESCRIPTOR.message_types_by_name['TypeProto'] = _TYPEPROTO +DESCRIPTOR.message_types_by_name['OperatorSetIdProto'] = _OPERATORSETIDPROTO +DESCRIPTOR.message_types_by_name['FunctionProto'] = _FUNCTIONPROTO +DESCRIPTOR.enum_types_by_name['Version'] = _VERSION +DESCRIPTOR.enum_types_by_name['OperatorStatus'] = _OPERATORSTATUS +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +AttributeProto = _reflection.GeneratedProtocolMessageType('AttributeProto', (_message.Message,), dict( + DESCRIPTOR = _ATTRIBUTEPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.AttributeProto) + )) +_sym_db.RegisterMessage(AttributeProto) + +ValueInfoProto = _reflection.GeneratedProtocolMessageType('ValueInfoProto', (_message.Message,), dict( + DESCRIPTOR = _VALUEINFOPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.ValueInfoProto) + )) +_sym_db.RegisterMessage(ValueInfoProto) + +NodeProto = _reflection.GeneratedProtocolMessageType('NodeProto', (_message.Message,), dict( + DESCRIPTOR = _NODEPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.NodeProto) + )) +_sym_db.RegisterMessage(NodeProto) + +ModelProto = _reflection.GeneratedProtocolMessageType('ModelProto', (_message.Message,), dict( + DESCRIPTOR = _MODELPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.ModelProto) + )) +_sym_db.RegisterMessage(ModelProto) + +StringStringEntryProto = _reflection.GeneratedProtocolMessageType('StringStringEntryProto', (_message.Message,), dict( + DESCRIPTOR = _STRINGSTRINGENTRYPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto) + )) +_sym_db.RegisterMessage(StringStringEntryProto) + +TensorAnnotation = _reflection.GeneratedProtocolMessageType('TensorAnnotation', (_message.Message,), dict( + DESCRIPTOR = _TENSORANNOTATION, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TensorAnnotation) + )) +_sym_db.RegisterMessage(TensorAnnotation) + +GraphProto = _reflection.GeneratedProtocolMessageType('GraphProto', (_message.Message,), dict( + DESCRIPTOR = _GRAPHPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.GraphProto) + )) +_sym_db.RegisterMessage(GraphProto) + +TensorProto = _reflection.GeneratedProtocolMessageType('TensorProto', (_message.Message,), dict( + + Segment = _reflection.GeneratedProtocolMessageType('Segment', (_message.Message,), dict( + DESCRIPTOR = _TENSORPROTO_SEGMENT, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment) + )) + , + DESCRIPTOR = _TENSORPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TensorProto) + )) +_sym_db.RegisterMessage(TensorProto) +_sym_db.RegisterMessage(TensorProto.Segment) + +TensorShapeProto = _reflection.GeneratedProtocolMessageType('TensorShapeProto', (_message.Message,), dict( + + Dimension = _reflection.GeneratedProtocolMessageType('Dimension', (_message.Message,), dict( + DESCRIPTOR = _TENSORSHAPEPROTO_DIMENSION, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension) + )) + , + DESCRIPTOR = _TENSORSHAPEPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TensorShapeProto) + )) +_sym_db.RegisterMessage(TensorShapeProto) +_sym_db.RegisterMessage(TensorShapeProto.Dimension) + +TypeProto = _reflection.GeneratedProtocolMessageType('TypeProto', (_message.Message,), dict( + + Tensor = _reflection.GeneratedProtocolMessageType('Tensor', (_message.Message,), dict( + DESCRIPTOR = _TYPEPROTO_TENSOR, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor) + )) + , + + Sequence = _reflection.GeneratedProtocolMessageType('Sequence', (_message.Message,), dict( + DESCRIPTOR = _TYPEPROTO_SEQUENCE, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence) + )) + , + + Map = _reflection.GeneratedProtocolMessageType('Map', (_message.Message,), dict( + DESCRIPTOR = _TYPEPROTO_MAP, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TypeProto.Map) + )) + , + + Opaque = _reflection.GeneratedProtocolMessageType('Opaque', (_message.Message,), dict( + DESCRIPTOR = _TYPEPROTO_OPAQUE, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TypeProto.Opaque) + )) + , + + SparseTensor = _reflection.GeneratedProtocolMessageType('SparseTensor', (_message.Message,), dict( + DESCRIPTOR = _TYPEPROTO_SPARSETENSOR, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor) + )) + , + DESCRIPTOR = _TYPEPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.TypeProto) + )) +_sym_db.RegisterMessage(TypeProto) +_sym_db.RegisterMessage(TypeProto.Tensor) +_sym_db.RegisterMessage(TypeProto.Sequence) +_sym_db.RegisterMessage(TypeProto.Map) +_sym_db.RegisterMessage(TypeProto.Opaque) +_sym_db.RegisterMessage(TypeProto.SparseTensor) + +OperatorSetIdProto = _reflection.GeneratedProtocolMessageType('OperatorSetIdProto', (_message.Message,), dict( + DESCRIPTOR = _OPERATORSETIDPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto) + )) +_sym_db.RegisterMessage(OperatorSetIdProto) + +FunctionProto = _reflection.GeneratedProtocolMessageType('FunctionProto', (_message.Message,), dict( + DESCRIPTOR = _FUNCTIONPROTO, + __module__ = 'onnx_ml_pb2' + # @@protoc_insertion_point(class_scope:onnx.FunctionProto) + )) +_sym_db.RegisterMessage(FunctionProto) + + +_TENSORPROTO.fields_by_name['float_data']._options = None +_TENSORPROTO.fields_by_name['int32_data']._options = None +_TENSORPROTO.fields_by_name['int64_data']._options = None +_TENSORPROTO.fields_by_name['double_data']._options = None +_TENSORPROTO.fields_by_name['uint64_data']._options = None +# @@protoc_insertion_point(module_scope) diff --git a/Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/predict_pb2.py b/Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/predict_pb2.py new file mode 100644 index 000000000..c71c138ac --- /dev/null +++ b/Research/kubeflow-on-azure-stack-lab/04-KFServing/assets/predict_pb2.py @@ -0,0 +1,215 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: predict.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +import assets.onnx_ml_pb2 as onnx__ml__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='predict.proto', + package='onnxruntime.server', + syntax='proto3', + serialized_options=None, + serialized_pb=_b('\n\rpredict.proto\x12\x12onnxruntime.server\x1a\ronnx-ml.proto\"\xaf\x01\n\x0ePredictRequest\x12>\n\x06inputs\x18\x02 \x03(\x0b\x32..onnxruntime.server.PredictRequest.InputsEntry\x12\x15\n\routput_filter\x18\x03 \x03(\t\x1a@\n\x0bInputsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12 \n\x05value\x18\x02 \x01(\x0b\x32\x11.onnx.TensorProto:\x02\x38\x01J\x04\x08\x01\x10\x02\"\x97\x01\n\x0fPredictResponse\x12\x41\n\x07outputs\x18\x01 \x03(\x0b\x32\x30.onnxruntime.server.PredictResponse.OutputsEntry\x1a\x41\n\x0cOutputsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12 \n\x05value\x18\x02 \x01(\x0b\x32\x11.onnx.TensorProto:\x02\x38\x01\x62\x06proto3') + , + dependencies=[onnx__ml__pb2.DESCRIPTOR,]) + + + + +_PREDICTREQUEST_INPUTSENTRY = _descriptor.Descriptor( + name='InputsEntry', + full_name='onnxruntime.server.PredictRequest.InputsEntry', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key', full_name='onnxruntime.server.PredictRequest.InputsEntry.key', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='value', full_name='onnxruntime.server.PredictRequest.InputsEntry.value', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=_b('8\001'), + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=158, + serialized_end=222, +) + +_PREDICTREQUEST = _descriptor.Descriptor( + name='PredictRequest', + full_name='onnxruntime.server.PredictRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='inputs', full_name='onnxruntime.server.PredictRequest.inputs', index=0, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='output_filter', full_name='onnxruntime.server.PredictRequest.output_filter', index=1, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[_PREDICTREQUEST_INPUTSENTRY, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=53, + serialized_end=228, +) + + +_PREDICTRESPONSE_OUTPUTSENTRY = _descriptor.Descriptor( + name='OutputsEntry', + full_name='onnxruntime.server.PredictResponse.OutputsEntry', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key', full_name='onnxruntime.server.PredictResponse.OutputsEntry.key', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + _descriptor.FieldDescriptor( + name='value', full_name='onnxruntime.server.PredictResponse.OutputsEntry.value', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + serialized_options=_b('8\001'), + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=317, + serialized_end=382, +) + +_PREDICTRESPONSE = _descriptor.Descriptor( + name='PredictResponse', + full_name='onnxruntime.server.PredictResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='outputs', full_name='onnxruntime.server.PredictResponse.outputs', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + serialized_options=None, file=DESCRIPTOR), + ], + extensions=[ + ], + nested_types=[_PREDICTRESPONSE_OUTPUTSENTRY, ], + enum_types=[ + ], + serialized_options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=231, + serialized_end=382, +) + +_PREDICTREQUEST_INPUTSENTRY.fields_by_name['value'].message_type = onnx__ml__pb2._TENSORPROTO +_PREDICTREQUEST_INPUTSENTRY.containing_type = _PREDICTREQUEST +_PREDICTREQUEST.fields_by_name['inputs'].message_type = _PREDICTREQUEST_INPUTSENTRY +_PREDICTRESPONSE_OUTPUTSENTRY.fields_by_name['value'].message_type = onnx__ml__pb2._TENSORPROTO +_PREDICTRESPONSE_OUTPUTSENTRY.containing_type = _PREDICTRESPONSE +_PREDICTRESPONSE.fields_by_name['outputs'].message_type = _PREDICTRESPONSE_OUTPUTSENTRY +DESCRIPTOR.message_types_by_name['PredictRequest'] = _PREDICTREQUEST +DESCRIPTOR.message_types_by_name['PredictResponse'] = _PREDICTRESPONSE +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + +PredictRequest = _reflection.GeneratedProtocolMessageType('PredictRequest', (_message.Message,), dict( + + InputsEntry = _reflection.GeneratedProtocolMessageType('InputsEntry', (_message.Message,), dict( + DESCRIPTOR = _PREDICTREQUEST_INPUTSENTRY, + __module__ = 'predict_pb2' + # @@protoc_insertion_point(class_scope:onnxruntime.server.PredictRequest.InputsEntry) + )) + , + DESCRIPTOR = _PREDICTREQUEST, + __module__ = 'predict_pb2' + # @@protoc_insertion_point(class_scope:onnxruntime.server.PredictRequest) + )) +_sym_db.RegisterMessage(PredictRequest) +_sym_db.RegisterMessage(PredictRequest.InputsEntry) + +PredictResponse = _reflection.GeneratedProtocolMessageType('PredictResponse', (_message.Message,), dict( + + OutputsEntry = _reflection.GeneratedProtocolMessageType('OutputsEntry', (_message.Message,), dict( + DESCRIPTOR = _PREDICTRESPONSE_OUTPUTSENTRY, + __module__ = 'predict_pb2' + # @@protoc_insertion_point(class_scope:onnxruntime.server.PredictResponse.OutputsEntry) + )) + , + DESCRIPTOR = _PREDICTRESPONSE, + __module__ = 'predict_pb2' + # @@protoc_insertion_point(class_scope:onnxruntime.server.PredictResponse) + )) +_sym_db.RegisterMessage(PredictResponse) +_sym_db.RegisterMessage(PredictResponse.OutputsEntry) + + +_PREDICTREQUEST_INPUTSENTRY._options = None +_PREDICTRESPONSE_OUTPUTSENTRY._options = None +# @@protoc_insertion_point(module_scope)