I have a TensorFlow Keras model in a format "saved model". I have converted it to "onnx" as "syrnt_v6.onnx". I have a Python script that does inference with the model in "saved model" format. How can I change my Python script for inference with the "onnx" converted model?
Here is my script:
import sys
import os
import numpy as np
import warnings
import cv2
import seaborn as sns
from tensorflow.keras.models import load_model
import tensorflow as tf
from tensorflow.keras import backend as K
from tensorflow.keras import layers
import tensorflow.keras.losses
from tensorflow.keras.layers import *
from models import *
from gt_gen_utils import *
import click
import json
from tensorflow.python.keras import backend as tensorflow_backend
import xml.etree.ElementTree as ET
import matplotlib.pyplot as plt

with warnings.catch_warnings():
    warnings.simplefilter("ignore")

__doc__=\
"""
Tool to load model and predict for given image.
"""

class sbb_predict:
    def __init__(self, image, model, task, config_params_model, save, out):
        self.image=image
        self.save=save
        self.model_dir=model
        self.task=task
        self.config_params_model=config_params_model
        self.out = out
        self.contours_file = os.path.join(self.out, "contours.txt")  # Path for contours output

    def resize_image(self,img_in,input_height,input_width):
        return cv2.resize( img_in, ( input_width,input_height) ,interpolation=cv2.INTER_NEAREST)

    def IoU(self,Yi,y_predi):
        ## mean Intersection over Union
        ## Mean IoU = TP/(FN + TP + FP)

        IoUs = []
        Nclass = np.unique(Yi)
        for c in Nclass:
            TP = np.sum( (Yi == c)&(y_predi==c) )
            FP = np.sum( (Yi != c)&(y_predi==c) )
            FN = np.sum( (Yi == c)&(y_predi != c))
            IoU = TP/float(TP + FP + FN)
            if self.n_classes>2:
                print("class {:02.0f}: #TP={:6.0f}, #FP={:6.0f}, #FN={:5.0f}, IoU={:4.3f}".format(c,TP,FP,FN,IoU))
            IoUs.append(IoU)
        if self.n_classes>2:
            mIoU = np.mean(IoUs)
            print("_________________")
            print("Mean IoU: {:4.3f}".format(mIoU))
            return mIoU
        elif self.n_classes==2:
            mIoU = IoUs[1]
            print("_________________")
            print("IoU: {:4.3f}".format(mIoU))
            return mIoU

    def start_new_session_and_model(self):

        config = tf.compat.v1.ConfigProto()
        config.gpu_options.allow_growth = True

        session = tf.compat.v1.Session(config=config)  # tf.InteractiveSession()
        tensorflow_backend.set_session(session)
        self.model = load_model(self.model_dir , compile=False,custom_objects = {"PatchEncoder": PatchEncoder, "Patches": Patches})

        if (self.task != 'classification' and self.task != 'reading_order'):
            self.img_height=self.model.layers[len(self.model.layers)-1].output_shape[1]
            self.img_width=self.model.layers[len(self.model.layers)-1].output_shape[2]
            self.n_classes=self.model.layers[len(self.model.layers)-1].output_shape[3]

    def visualize_model_output(self, prediction, img, task):
        unique_classes = np.unique(prediction[:,:,0])
        rgb_colors = {'0' : [255, 255, 255],
                    '1' : [255, 0, 0],
                    '2' : [255, 125, 0],
                    '3' : [255, 0, 125],
                    '4' : [125, 125, 125],
                    '5' : [125, 125, 0],
                    '6' : [0, 125, 255],
                    '7' : [0, 125, 0],
                    '8' : [125, 125, 125],
                    '9' : [0, 125, 255],
                    '10' : [125, 0, 125],
                    '11' : [0, 255, 0],
                    '12' : [0, 0, 255],
                    '13' : [0, 255, 255],
                    '14' : [255, 125, 125],
                    '15' : [255, 0, 255]}

        layout_only = np.zeros(prediction.shape)

        for unq_class in unique_classes:
            rgb_class_unique = rgb_colors[str(int(unq_class))]
            layout_only[:,:,0][prediction[:,:,0]==unq_class] = rgb_class_unique[0]
            layout_only[:,:,1][prediction[:,:,0]==unq_class] = rgb_class_unique[1]
            layout_only[:,:,2][prediction[:,:,0]==unq_class] = rgb_class_unique[2]

        img = self.resize_image(img, layout_only.shape[0], layout_only.shape[1])

        layout_only = layout_only.astype(np.int32)
        img = img.astype(np.int32)

        added_image = cv2.addWeighted(img,0.5,layout_only,0.1,0)

        return added_image, layout_only

    def save_contours_to_file(self, contours):
        """Save contours and original image size to a text file as formatted tuples."""
        with open(self.contours_file, 'w') as f:
            # Write the original image size at the top
            f.write(f"ModelImageSize: {self.config_params_model['input_width']}, {self.config_params_model['input_height']}\n")  # width, height

            for contour in contours:
                # Convert contour array of points to desired string format
                formatted_contour = ' '.join(f"{point[0][0]},{point[0][1]}" for point in contour)
                f.write(formatted_contour + "\n")

    def predict(self):
        self.start_new_session_and_model()
        img=cv2.imread(self.image)
        self.img_org = np.copy(img)

        width=self.img_width
        height=self.img_height

        img=img/255.0
        img=self.resize_image(img,self.img_height,self.img_width)

        label_p_pred=self.model.predict(
            img.reshape(1,img.shape[0],img.shape[1],img.shape[2]))

        if self.task == 'segmentation':
              seg = np.argmax(label_p_pred, axis=3)[0]
              seg = np.repeat(seg[:, :, np.newaxis], 3, axis=2)

              # Find contours for the segmented image
              gray = cv2.cvtColor(seg.astype(np.uint8), cv2.COLOR_BGR2GRAY)
              contours, _ = cv2.findContours(gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

              # Save contours to text file
              self.save_contours_to_file(contours)

              prediction_true = seg.astype(int)
              prediction_true = cv2.resize(prediction_true, (self.img_org.shape[1], self.img_org.shape[0]), interpolation=cv2.INTER_NEAREST)
              return prediction_true

    def run(self):
        res=self.predict()
        img_seg_overlayed, only_layout  = self.visualize_model_output(res, self.img_org, self.task)
        if self.save:
            cv2.imwrite(self.save,img_seg_overlayed)

@click.command()
@click.option(
    "--image",
    "-i",
    help="image filename",
    type=click.Path(exists=True, dir_okay=False),
)
@click.option(
    "--out",
    "-o",
    help="output directory where contours and other files will be written.",
    type=click.Path(exists=True, file_okay=False),
)
@click.option(
    "--save",
    "-s",
    help="save prediction as a png file in current folder.",
)
@click.option(
    "--model",
    "-m",
    help="directory of models",
    type=click.Path(exists=True, file_okay=False),
    required=True,
)
def main(image, model, save, out):
    with open(os.path.join(model, 'config.json')) as f:
        config_params_model = json.load(f)
    task = config_params_model['task']
    if (task != 'classification' and task != 'reading_order'):
        if not save:
            print("Error: You used one of segmentation task but not set -s, you need a filename to save visualized output with -s")
            sys.exit(1)
    x = sbb_predict(image, model, task, config_params_model, save, out)
    x.run()

if __name__ == "__main__":
    main()