class_docstr: Model optimized using OpenVINO.
  
  The class cannot be directly instantiated, but implements all the core
  methods needed for using OpenVINO at inference time.
  
  Attributes:
      network_parameters (ModelParams): The model parameters as batch
              size, input and output sizes.
      exec_network (any): The graph executor. This is the
          central component in the OpenVino optimized model execution.
      input_keys (List): Keys associated to the inputs.
      output_keys (List): Keys associated to the outputs.
      description_file (str): File containing a description of the optimized
          model.
      weights_file (str): File containing the model weights.
docstr: Build the optimized model from the network description and its
  weights.
  
  Args:
      network_parameters (ModelParams): The model parameters as batch
          size, input and output sizes.
      model_name (str): File containing a description of the optimized
          model.
      model_weights (str): File containing the model weights.
      device (Device): Device used to run the model.
      input_tfms (MultiStageTransformation, optional): Transformations
          to be performed to the model's input tensors in order to
          get the prediction.
      input_data (DataManager, optional): User defined data.
code: def from_model_name(
      cls,
      network_parameters: ModelParams,
      model_name: str,
      model_weights: str,
      device: Device,
      input_tfms: MultiStageTransformation = None,
      input_data: DataManager = None,
      **kwargs,
  ):
      """Build the optimized model from the network description and its
      weights.
  
      Args:
          network_parameters (ModelParams): The model parameters as batch
              size, input and output sizes.
          model_name (str): File containing a description of the optimized
              model.
          model_weights (str): File containing the model weights.
          device (Device): Device used to run the model.
          input_tfms (MultiStageTransformation, optional): Transformations
              to be performed to the model's input tensors in order to
              get the prediction.
          input_data (DataManager, optional): User defined data.
      """
      if len(kwargs) > 0:
          logger.warning(f"Found extra parameters: {kwargs}")
  
      core = Core()
      model = core.read_model(model=model_name, weights=model_weights)
  
      dynamic_shape = cls._get_dynamic_shape(model, network_parameters)
  
      if dynamic_shape is not None:
          model.reshape(dynamic_shape)
  
      compiled_model = core.compile_model(
          model=model, device_name="CPU"
      )
      infer_request = compiled_model.create_infer_request()
  
      input_keys = list(
          map(lambda obj: obj.get_any_name(), compiled_model.inputs)
      )
      output_keys = list(
          map(lambda obj: obj.get_any_name(), compiled_model.outputs)
      )
  
      return cls(
          compiled_model,
          infer_request,
          input_keys,
          output_keys,
          input_tfms=input_tfms,
          network_parameters=network_parameters,
          description_file=model_name,
          weights_file=model_weights,
          input_data=input_data,
          device=device,
      )
  
imports: import json
  import shutil
  from abc import ABC
  from pathlib import Path
  from typing import Dict, Union, Type, Generator, Tuple, List, Optional
  import numpy
  from loguru import logger
  from nebullvm.config import OPENVINO_FILENAMES
  from nebullvm.core.models import Device, ModelParams, DeepLearningFramework
  from nebullvm.operations.inference_learners.base import BaseInferenceLearner, LearnerMetadata, PytorchBaseInferenceLearner, TensorflowBaseInferenceLearner, NumpyBaseInferenceLearner
  from nebullvm.optional_modules.openvino import Core, Model, CompiledModel, InferRequest
  from nebullvm.optional_modules.tensorflow import tensorflow
  from nebullvm.optional_modules.torch import torch
  from nebullvm.tools.data import DataManager
  from nebullvm.tools.transformations import MultiStageTransformation
label_desc: Use image node_id 5 for calling the OpenVinoInferenceLearner obj's underlying member method code with example usage: obj.from_model_name(cls, network_parameters, model_name, model_weights, device, input_tfms, input_data) and returns: cls