code: def bytes_to_unicode():
      """
      Returns list of utf-8 byte and a mapping to unicode strings. We specifically avoids mapping to whitespace/control
      characters the bpe code barfs on.
  
      The reversible bpe codes work on unicode strings. This means you need a large # of unicode characters in your vocab
      if you want to avoid UNKs. When you're at something like a 10B token dataset you end up needing around 5K for
      decent coverage. This is a significant percentage of your normal, say, 32K bpe vocab. To avoid that, we want lookup
      tables between utf-8 bytes and unicode strings.
      """
      bs = (
          list(range(ord("!"), ord("~") + 1))
          + list(range(ord("¡"), ord("¬") + 1))
          + list(range(ord("®"), ord("ÿ") + 1))
      )
      cs = bs[:]
      n = 0
      for b in range(2**8):
          if b not in bs:
              bs.append(b)
              cs.append(2**8 + n)
              n += 1
      cs = [chr(n) for n in cs]
      return dict(zip(bs, cs))
  
imports: import json
  import os
  from functools import lru_cache
  from typing import Dict, List, Optional, Tuple, Union
  import regex
  from ...tokenization_utils import AddedToken, PreTrainedTokenizer
  from ...tokenization_utils_base import BatchEncoding, EncodedInput, PreTokenizedInput, TextInput, TextInputPair, TruncationStrategy
  from ...utils import PaddingStrategy, TensorType, add_end_docstrings, logging
label_desc: Use image node_id 1 for calling a global function with example usage: bytes_to_unicode() and returns: dict