def METHOD_NAME(self, requests):
    """`execute` must be implemented in every Python model. `execute`
    function receives a list of pb_utils.InferenceRequest as the only
    argument. This function is called when an inference is requested
    for this model.
    Parameters
    ----------
    requests : list
      A list of pb_utils.InferenceRequest
    Returns
    -------
    list
      A list of pb_utils.InferenceResponse. The length of this list must
      be the same as `requests`
    """
    batch_count = []
    total_waves = []
    batch_len = []
    responses = []
    for request in requests:
        input0 = pb_utils.get_input_tensor_by_name(request, "wav")
        input1 = pb_utils.get_input_tensor_by_name(request, "wav_lens")
        cur_b_wav = input0.as_numpy()
        cur_b_wav = cur_b_wav * (1 << 15)  # b x -1
        cur_b_wav_lens = input1.as_numpy()  # b x 1
        cur_batch = cur_b_wav.shape[0]
        cur_len = cur_b_wav.shape[1]
        batch_count.append(cur_batch)
        batch_len.append(cur_len)
        for wav, wav_len in zip(cur_b_wav, cur_b_wav_lens):
            wav_len = wav_len[0]
            wav = torch.tensor(wav[0:wav_len], dtype=torch.float32,
                               device=self.device)
            total_waves.append(wav)
    features = self.feature_extractor(total_waves)
    idx = 0
    for b, l in zip(batch_count, batch_len):
        expect_feat_len = _kaldifeat.num_frames(l, self.opts.frame_opts)
        speech = torch.zeros((b, expect_feat_len, self.feature_size),
                             dtype=self.output0_dtype, device=self.device)
        speech_lengths = torch.zeros((b, 1), dtype=torch.int32, device=self.device)
        for i in range(b):
            f = features[idx]
            f_l = f.shape[0]
            speech[i, 0: f_l, :] = f.to(self.output0_dtype)
            speech_lengths[i][0] = f_l
            idx += 1
        # put speech feature on device will cause empty output
        # we will follow this issue and now temporarily put it on cpu
        speech = speech.cpu()
        speech_lengths = speech_lengths.cpu()
        out0 = pb_utils.Tensor.from_dlpack("speech", to_dlpack(speech))
        out1 = pb_utils.Tensor.from_dlpack("speech_lengths",
                                           to_dlpack(speech_lengths))
        inference_response = pb_utils.InferenceResponse(output_tensors=[out0, out1])
        responses.append(inference_response)
    return responses