code: def run_transformer_int4_gpu(
      repo_id,
      local_model_hub,
      in_out_pairs,
      warm_up,
      num_trials,
      num_beams,
      low_bit,
  ):
      from bigdl.llm.transformers import AutoModel, AutoModelForCausalLM
      from transformers import (
          AutoTokenizer,
          GPTJForCausalLM,
          LlamaTokenizer,
      )
      import intel_extension_for_pytorch as ipex
  
      reserved_mem_list = []
      model_path = get_model_path(repo_id, local_model_hub)
      # Load model in 4 bit,
      # which convert the relevant layers in the model into INT4 format
      st = time.perf_counter()
      if repo_id in CHATGLM_IDS:
          model = AutoModel.from_pretrained(
              model_path,
              load_in_low_bit=low_bit,
              optimize_model=True,
              trust_remote_code=True,
              use_cache=True,
          ).eval()
          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,
              load_in_low_bit=low_bit,
              trust_remote_code=True,
              use_cache=True,
          ).eval()
          tokenizer = LlamaTokenizer.from_pretrained(
              model_path, trust_remote_code=True
          )
          model = model.to("xpu")
      else:
          model = AutoModelForCausalLM.from_pretrained(
              model_path,
              optimize_model=True,
              load_in_low_bit=low_bit,
              trust_remote_code=True,
              use_cache=True,
          ).eval()
          tokenizer = AutoTokenizer.from_pretrained(
              model_path, trust_remote_code=True
          )
          model = model.to("xpu")
          if isinstance(model, GPTJForCausalLM):
              # For gpt-j model family, this optimization can provide a better performance.
              model = ipex.optimize(model.eval(), inplace=True)
      end = time.perf_counter()
      print(">> loading of model costs {}s".format(end - st))
      reserved_mem_list.append(
          torch.xpu.memory.memory_reserved() / (1024**3)
      )
  
      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])
              i = 0
              with open("prompt/stress_test.txt", "r") as file:
                  for input_str in file:
                      # 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] = []
                      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()
                      reserved_mem_list.append(
                          torch.xpu.memory.memory_reserved()
                          / (1024**3)
                      )
                      gpu_peak_mem = max(
                          reserved_mem_list
                      )  # always keep the peak gpu mem at current stage
                      output_ids = output_ids.cpu()
                      print("model generate cost: " + str(end - st))
                      output = tokenizer.batch_decode(output_ids)
                      print(output[0])
                      actual_out_len = (
                          output_ids.shape[1] - actual_in_len
                      )
                      if i >= warm_up:
                          result[in_out].append(
                              [
                                  model.first_cost,
                                  model.rest_cost_mean,
                                  model.encoder_time,
                                  actual_in_len,
                                  actual_out_len,
                                  gpu_peak_mem,
                              ]
                          )
                      i += 1
                      if i >= warm_up + num_trials:
                          break
      model.to("cpu")
      torch.xpu.synchronize()
      torch.xpu.empty_cache()
      del model
      gc.collect()
      return result
  
file_path: BigDL/python/llm/dev/benchmark/all-in-one/run-stress-test.py
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 4 for calling a global function with example usage: run_transformer_int4_gpu(repo_id, local_model_hub, in_out_pairs, warm_up, num_trials, num_beams, low_bit) and returns: result