code: def create_masked_lm_predictions(
      tokens,
      masked_lm_prob,
      max_predictions_per_seq,
      whole_word_mask,
      vocab,
      tokenizer,
      _MASK_TOKEN,
      _CLS_TOKEN,
      _SEP_TOKEN,
  ):
      """Creates the predictions for the masked LM objective."""
      cand_indexes = []
      for i, token in enumerate(tokens):
          if token in [_CLS_TOKEN, _SEP_TOKEN]:
              continue
          # Whole Word Masking means that if we mask all of the subwords
          # corresponding to an original word. When a word has been split into
          # subwords, the first token does not have any marker and any subsequence
          # tokens are prefixed with ##. So whenever we see the ## token, we
          # append it to the previous set of word indexes.
          #
          # Note that Whole Word Masking does *not* change the training code
          # at all -- we still predict each subword independently, softmaxed
          # over the entire vocabulary.
          if (
              whole_word_mask
              and len(cand_indexes) >= 1
              and not tokenizer.is_first_subword(token)
          ):
              cand_indexes[-1].append(i)
          else:
              cand_indexes.append([i])
  
      random.shuffle(cand_indexes)
  
      output_tokens = list(tokens)
  
      num_to_predict = min(
          max_predictions_per_seq,
          max(1, int(round(len(tokens) * masked_lm_prob))),
      )
  
      masked_lms = []
      covered_indexes = set()
      for index_set in cand_indexes:
          if len(masked_lms) >= num_to_predict:
              break
          # If adding a whole-word mask would exceed the maximum number of
          # predictions, then just skip this candidate.
          if len(masked_lms) + len(index_set) > num_to_predict:
              continue
          is_any_index_covered = False
          for index in index_set:
              if index in covered_indexes:
                  is_any_index_covered = True
                  break
          if is_any_index_covered:
              continue
          for index in index_set:
              covered_indexes.add(index)
              masked_token = None
              # 80% of the time, replace with [MASK]
              if random.random() < 0.8:
                  masked_token = _MASK_TOKEN
              else:
                  # 10% of the time, keep original
                  if random.random() < 0.5:
                      masked_token = tokens[index]
                  # 10% of the time, replace with random word
                  else:
                      # generate a random word in [0, vocab_size - 1]
                      masked_token = random.randint(0, len(vocab) - 1)
  
              output_tokens[index] = masked_token
  
              masked_lms.append(
                  MaskedLmInstance(index=index, label=tokens[index])
              )
      assert len(masked_lms) <= num_to_predict
      masked_lms = sorted(masked_lms, key=lambda x: x.index)
  
      masked_lm_positions = []
      masked_lm_labels = []
      for p in masked_lms:
          masked_lm_positions.append(p.index)
          masked_lm_labels.append(p.label)
  
      return (output_tokens, masked_lm_positions, masked_lm_labels)
  
imports: import argparse
  import logging
  import io
  import os
  import glob
  import collections
  import warnings
  import random
  import time
  from multiprocessing import Pool
  import numpy
  from gluonnlp.models.bert import BertModel, BertForPretrain, get_pretrained_bert
  import gluonnlp
label_desc: Use image node_id 8 for calling a global function with example usage: create_masked_lm_predictions(tokens, masked_lm_prob, max_predictions_per_seq, whole_word_mask, vocab, tokenizer, _MASK_TOKEN, _CLS_TOKEN, _SEP_TOKEN) and returns: output_tokens,  masked_lm_positions,  masked_lm_labels