parameters: (clipper_conn,
                              name,
                              input_type,
                              inputs,
                              func,
                              pytorch_model,
                              default_output="None",
                              version=1,
                              slo_micros=3000000,
                              labels=None,
                              registry=None,
                              base_image=None,
                              num_replicas=1,
                              onnx_backend="caffe2",
                              batch_size=-1,
                              pkgs_to_install=None)
docstring: This function deploys the prediction function with a PyTorch model.
      It serializes the PyTorch model in Onnx format and creates a container that loads it as a
      Caffe2 model.
  
      Parameters
      ----------
      clipper_conn : :py:meth:`clipper_admin.ClipperConnection`
          A ``ClipperConnection`` object connected to a running Clipper cluster.
      name : str
          The name to be assigned to both the registered application and deployed model.
      input_type : str
          The input_type to be associated with the registered app and deployed model.
          One of "integers", "floats", "doubles", "bytes", or "strings".
      inputs :
          input of func.
      func : function
          The prediction function. Any state associated with the function will be
          captured via closure capture and pickled with Cloudpickle.
      pytorch_model : pytorch model object
          The PyTorch model to save.
      default_output : str, optional
          The default output for the application. The default output will be returned whenever
          an application is unable to receive a response from a model within the specified
          query latency SLO (service level objective). The reason the default output was returned
          is always provided as part of the prediction response object. Defaults to "None".
      version : str, optional
          The version to assign this model. Versions must be unique on a per-model
          basis, but may be re-used across different models.
      slo_micros : int, optional
          The query latency objective for the application in microseconds.
          This is the processing latency between Clipper receiving a request
          and sending a response. It does not account for network latencies
          before a request is received or after a response is sent.
          If Clipper cannot process a query within the latency objective,
          the default output is returned. Therefore, it is recommended that
          the SLO not be set aggressively low unless absolutely necessary.
          100000 (100ms) is a good starting value, but the optimal latency objective
          will vary depending on the application.
      labels : list(str), optional
          A list of strings annotating the model. These are ignored by Clipper
          and used purely for user annotations.
      registry : str, optional
          The Docker container registry to push the freshly built model to. Note
          that if you are running Clipper on Kubernetes, this registry must be accesible
          to the Kubernetes cluster in order to fetch the container from the registry.
      base_image : str, optional
          The base Docker image to build the new model image from. This
          image should contain all code necessary to run a Clipper model
          container RPC client.
      num_replicas : int, optional
          The number of replicas of the model to create. The number of replicas
          for a model can be changed at any time with
          :py:meth:`clipper.ClipperConnection.set_num_replicas`.
      onnx_backend : str, optional
          The provided onnx backend.Caffe2 is the only currently supported ONNX backend.
      batch_size : int, optional
          The user-defined query batch size for the model. Replicas of the model will attempt
          to process at most `batch_size` queries simultaneously. They may process smaller
          batches if `batch_size` queries are not immediately available.
          If the default value of -1 is used, Clipper will adaptively calculate the batch size for
          individual replicas of this model.
      pkgs_to_install : list (of strings), optional
          A list of the names of packages to install, using pip, in the container.
          The names must be strings.
docstring_summary: This function deploys the prediction function with a PyTorch model.
      It serializes the PyTorch model in Onnx format and creates a container that loads it as a
      Caffe2 model.
docstring_tokens: This function deploys the prediction function with a PyTorch model . It serializes the PyTorch model in Onnx format and creates a container that loads it as a Caffe2 model .
function: def create_pytorch_endpoint(clipper_conn,
                              name,
                              input_type,
                              inputs,
                              func,
                              pytorch_model,
                              default_output="None",
                              version=1,
                              slo_micros=3000000,
                              labels=None,
                              registry=None,
                              base_image=None,
                              num_replicas=1,
                              onnx_backend="caffe2",
                              batch_size=-1,
                              pkgs_to_install=None):
      """This function deploys the prediction function with a PyTorch model.
      It serializes the PyTorch model in Onnx format and creates a container that loads it as a
      Caffe2 model.
  
      Parameters
      ----------
      clipper_conn : :py:meth:`clipper_admin.ClipperConnection`
          A ``ClipperConnection`` object connected to a running Clipper cluster.
      name : str
          The name to be assigned to both the registered application and deployed model.
      input_type : str
          The input_type to be associated with the registered app and deployed model.
          One of "integers", "floats", "doubles", "bytes", or "strings".
      inputs :
          input of func.
      func : function
          The prediction function. Any state associated with the function will be
          captured via closure capture and pickled with Cloudpickle.
      pytorch_model : pytorch model object
          The PyTorch model to save.
      default_output : str, optional
          The default output for the application. The default output will be returned whenever
          an application is unable to receive a response from a model within the specified
          query latency SLO (service level objective). The reason the default output was returned
          is always provided as part of the prediction response object. Defaults to "None".
      version : str, optional
          The version to assign this model. Versions must be unique on a per-model
          basis, but may be re-used across different models.
      slo_micros : int, optional
          The query latency objective for the application in microseconds.
          This is the processing latency between Clipper receiving a request
          and sending a response. It does not account for network latencies
          before a request is received or after a response is sent.
          If Clipper cannot process a query within the latency objective,
          the default output is returned. Therefore, it is recommended that
          the SLO not be set aggressively low unless absolutely necessary.
          100000 (100ms) is a good starting value, but the optimal latency objective
          will vary depending on the application.
      labels : list(str), optional
          A list of strings annotating the model. These are ignored by Clipper
          and used purely for user annotations.
      registry : str, optional
          The Docker container registry to push the freshly built model to. Note
          that if you are running Clipper on Kubernetes, this registry must be accesible
          to the Kubernetes cluster in order to fetch the container from the registry.
      base_image : str, optional
          The base Docker image to build the new model image from. This
          image should contain all code necessary to run a Clipper model
          container RPC client.
      num_replicas : int, optional
          The number of replicas of the model to create. The number of replicas
          for a model can be changed at any time with
          :py:meth:`clipper.ClipperConnection.set_num_replicas`.
      onnx_backend : str, optional
          The provided onnx backend.Caffe2 is the only currently supported ONNX backend.
      batch_size : int, optional
          The user-defined query batch size for the model. Replicas of the model will attempt
          to process at most `batch_size` queries simultaneously. They may process smaller
          batches if `batch_size` queries are not immediately available.
          If the default value of -1 is used, Clipper will adaptively calculate the batch size for
          individual replicas of this model.
      pkgs_to_install : list (of strings), optional
          A list of the names of packages to install, using pip, in the container.
          The names must be strings.
      """
  
      clipper_conn.register_application(name, input_type, default_output,
                                        slo_micros)
      deploy_pytorch_model(clipper_conn, name, version, input_type, inputs, func,
                           pytorch_model, base_image, labels, registry,
                           num_replicas, onnx_backend, batch_size,
                           pkgs_to_install)
  
      clipper_conn.link_model_to_app(name, name)
function_tokens: def create_pytorch_endpoint ( clipper_conn , name , input_type , inputs , func , pytorch_model , default_output = "None" , version = 1 , slo_micros = 3000000 , labels = None , registry = None , base_image = None , num_replicas = 1 , onnx_backend = "caffe2" , batch_size = - 1 , pkgs_to_install = None ) : clipper_conn . register_application ( name , input_type , default_output , slo_micros ) deploy_pytorch_model ( clipper_conn , name , version , input_type , inputs , func , pytorch_model , base_image , labels , registry , num_replicas , onnx_backend , batch_size , pkgs_to_install ) clipper_conn . link_model_to_app ( name , name )