code: def read_squad_examples(input_file, is_training):
      """Read a SQuAD json file into a list of SquadExample."""
      with open(input_file, "r", encoding="utf-8") as reader:
          input_data = json.load(reader)["data"]
  
      def is_whitespace(c):
          if (
              c == " "
              or c == "\t"
              or c == "\r"
              or c == "\n"
              or ord(c) == 0x202F
          ):
              return True
          return False
  
      examples = []
      for entry in input_data:
          for paragraph in entry["paragraphs"]:
              paragraph_text = paragraph["context"]
              doc_tokens = []
              char_to_word_offset = []
              prev_is_whitespace = True
              for c in paragraph_text:
                  if is_whitespace(c):
                      prev_is_whitespace = True
                  else:
                      if prev_is_whitespace:
                          doc_tokens.append(c)
                      else:
                          doc_tokens[-1] += c
                      prev_is_whitespace = False
                  char_to_word_offset.append(len(doc_tokens) - 1)
  
              for qa in paragraph["qas"]:
                  qas_id = qa["id"]
                  question_text = qa["question"]
                  start_position = None
                  end_position = None
                  orig_answer_text = None
                  if is_training:
                      if len(qa["answers"]) != 1:
                          raise ValueError(
                              "For training, each question should have exactly 1 answer."
                          )
                      answer = qa["answers"][0]
                      orig_answer_text = answer["text"]
                      answer_offset = answer["answer_start"]
                      answer_length = len(orig_answer_text)
                      start_position = char_to_word_offset[
                          answer_offset
                      ]
                      end_position = char_to_word_offset[
                          answer_offset + answer_length - 1
                      ]
                      # Only add answers where the text can be exactly recovered from the
                      # document. If this CAN'T happen it's likely due to weird Unicode
                      # stuff so we will just skip the example.
                      #
                      # Note that this means for training mode, every example is NOT
                      # guaranteed to be preserved.
                      actual_text = " ".join(
                          doc_tokens[
                              start_position : (end_position + 1)
                          ]
                      )
                      cleaned_answer_text = " ".join(
                          whitespace_tokenize(orig_answer_text)
                      )
                      if actual_text.find(cleaned_answer_text) == -1:
                          logger.warning(
                              "Could not find answer: '%s' vs. '%s'",
                              actual_text,
                              cleaned_answer_text,
                          )
                          continue
  
                  example = SquadExample(
                      qas_id=qas_id,
                      question_text=question_text,
                      doc_tokens=doc_tokens,
                      orig_answer_text=orig_answer_text,
                      start_position=start_position,
                      end_position=end_position,
                  )
                  examples.append(example)
      return examples
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import argparse
  import collections
  import logging
  import json
  import math
  import os
  import random
  import pickle
  from tqdm import tqdm, trange
  from utils import get_argument_parser, get_summary_writer, write_summary_events, is_time_to_exit, check_early_exit_warning
  import numpy
  import torch
  from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler
  from torch.utils.data.distributed import DistributedSampler
  from pytorch_pretrained_bert.tokenization import whitespace_tokenize, BasicTokenizer, BertTokenizer
  from pytorch_pretrained_bert.optimization import BertAdam
  from pytorch_pretrained_bert.file_utils import PYTORCH_PRETRAINED_BERT_CACHE
  from apex import amp
  from turing.nvidia_modeling import BertForQuestionAnswering, BertConfig
  from apex.multi_tensor_apply import multi_tensor_applier
label_desc: Use image node_id 1 for calling a global function with example usage: read_squad_examples(input_file, is_training) and returns: examples, False, True