code: def run_bigdl_fp16_gpu(
      repo_id,
      local_model_hub,
      in_out_pairs,
      warm_up,
      num_trials,
      num_beams,
  ):
      from bigdl.llm.transformers import AutoModel, AutoModelForCausalLM
      from transformers import (
          AutoTokenizer,
          GPTJForCausalLM,
          LlamaTokenizer,
      )
      import intel_extension_for_pytorch as ipex
  
      model_path = get_model_path(repo_id, local_model_hub)
      st = time.perf_counter()
      if repo_id in CHATGLM_IDS:
          model = AutoModel.from_pretrained(
              model_path,
              trust_remote_code=True,
              use_cache=True,
              load_in_low_bit="fp16",
              torch_dtype=torch.float16,
          )
          tokenizer = AutoTokenizer.from_pretrained(
              model_path, trust_remote_code=True
          )
          model = model.to("xpu")
      elif repo_id in LLAMA_IDS:
          model = AutoModelForCausalLM.from_pretrained(
              model_path,
              trust_remote_code=True,
              use_cache=True,
              load_in_low_bit="fp16",
              torch_dtype=torch.float16,
          )
          tokenizer = LlamaTokenizer.from_pretrained(
              model_path, trust_remote_code=True
          )
          model = model.to("xpu")
      else:
          model = AutoModelForCausalLM.from_pretrained(
              model_path,
              trust_remote_code=True,
              use_cache=True,
              load_in_low_bit="fp16",
              torch_dtype=torch.float16,
          )
          tokenizer = AutoTokenizer.from_pretrained(
              model_path, trust_remote_code=True
          )
          model = model.to("xpu")
      end = time.perf_counter()
      print(">> loading of model costs {}s".format(end - st))
  
      model = BenchmarkWrapper(model)
  
      result = {}
      with torch.inference_mode():
          for in_out in in_out_pairs:
              in_out_len = in_out.split("-")
              in_len = int(in_out_len[0])
              out_len = int(in_out_len[1])
              # As different tokenizer has different encodings,
              # in_len.txt maybe shorter than we need,
              # use much longer context to make sure input length
              test_length = min(in_len * 2, 8192)
              while test_length not in [32, 256, 1024, 2048, 8192]:
                  test_length = test_length * 2
              input_str = open(f"prompt/{test_length}.txt", "r").read()
              # As different tokenizer has different encodings,
              # slice the input_ids to ensure the prompt length is required length.
              input_ids = tokenizer.encode(
                  input_str, return_tensors="pt"
              )
              input_ids = input_ids[:, :in_len]
              true_str = tokenizer.batch_decode(input_ids)[0]
              input_ids = tokenizer.encode(
                  true_str, return_tensors="pt"
              ).to("xpu")
              actual_in_len = input_ids.shape[1]
              result[in_out] = []
              for i in range(num_trials + warm_up):
                  st = time.perf_counter()
                  output_ids = model.generate(
                      input_ids,
                      do_sample=False,
                      max_new_tokens=out_len,
                      num_beams=num_beams,
                  )
                  torch.xpu.synchronize()
                  end = time.perf_counter()
                  output_ids = output_ids.cpu()
                  print("model generate cost: " + str(end - st))
                  output = tokenizer.batch_decode(output_ids)
                  actual_out_len = output_ids.shape[1] - actual_in_len
                  print(output[0])
                  if i >= warm_up:
                      result[in_out].append(
                          [
                              model.first_cost,
                              model.rest_cost_mean,
                              model.encoder_time,
                              actual_in_len,
                              actual_out_len,
                          ]
                      )
      del model
      torch.xpu.empty_cache()
      return result
  
imports: import torch
  import time
  import gc
  import traceback
  import threading
  import numpy
  from datetime import date
  import os
  import sys
  from benchmark_util import BenchmarkWrapper
  from bigdl.llm.utils.common.log4Error import invalidInputError
label_desc: Use image node_id 11 for calling a global function with example usage: run_bigdl_fp16_gpu(repo_id, local_model_hub, in_out_pairs, warm_up, num_trials, num_beams) and returns: result