code: def truncate_sequences(
      seq_a,
      seq_b,
      tokenizer,
      max_seq_len,
      truncation_strategy="longest_first",
      with_special_tokens=True,
      stride=0,
  ):
      """
      Reduces a single sequence or a pair of sequences to a maximum sequence length.
      The sequences can contain tokens or any other elements (offsets, masks ...).
      If `with_special_tokens` is enabled, it'll remove some additional tokens to have exactly enough space for later adding special tokens (CLS, SEP etc.)
  
      Supported truncation strategies:
  
      - longest_first: (default) Iteratively reduce the inputs sequence until the input is under max_length starting from the longest one at each token (when there is a pair of input sequences). Overflowing tokens only contains overflow from the first sequence.
      - only_first: Only truncate the first sequence. raise an error if the first sequence is shorter or equal to than num_tokens_to_remove.
      - only_second: Only truncate the second sequence
      - do_not_truncate: Does not truncate (raise an error if the input sequence is longer than max_length)
  
      :param seq_a: First sequence of tokens/offsets/...
      :type seq_a: list
      :param seq_b: Optional second sequence of tokens/offsets/...
      :type seq_b: None or list
      :param tokenizer: Tokenizer (e.g. from Tokenizer.load())
      :param max_seq_len:
      :type max_seq_len: int
      :param truncation_strategy: how the sequence(s) should be truncated down. Default: "longest_first" (see above for other options).
      :type truncation_strategy: str
      :param with_special_tokens: If true, it'll remove some additional tokens to have exactly enough space for later adding special tokens (CLS, SEP etc.)
      :type with_special_tokens: bool
      :param stride: optional stride of the window during truncation
      :type stride: int
      :return: truncated seq_a, truncated seq_b, overflowing tokens
  
      """
      pair = bool(seq_b is not None)
      len_a = len(seq_a)
      len_b = len(seq_b) if pair else 0
      num_special_tokens = (
          tokenizer.num_special_tokens_to_add(pair=pair)
          if with_special_tokens
          else 0
      )
      total_len = len_a + len_b + num_special_tokens
      overflowing_tokens = []
  
      if max_seq_len and total_len > max_seq_len:
          (
              seq_a,
              seq_b,
              overflowing_tokens,
          ) = tokenizer.truncate_sequences(
              seq_a,
              pair_ids=seq_b,
              num_tokens_to_remove=total_len - max_seq_len,
              truncation_strategy=truncation_strategy,
              stride=stride,
          )
      return (seq_a, seq_b, overflowing_tokens)
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import collections
  import json
  import logging
  import os
  import re
  from pathlib import Path
  import numpy
  from transformers import AlbertTokenizer, AlbertTokenizerFast, BertTokenizer, BertTokenizerFast, DistilBertTokenizer, DistilBertTokenizerFast, ElectraTokenizer, ElectraTokenizerFast, RobertaTokenizer, RobertaTokenizerFast, XLMRobertaTokenizer, XLMRobertaTokenizerFast, XLNetTokenizer, XLNetTokenizerFast, CamembertTokenizer, CamembertTokenizerFast, DPRContextEncoderTokenizer, DPRContextEncoderTokenizerFast, DPRQuestionEncoderTokenizer, DPRQuestionEncoderTokenizerFast, BigBirdTokenizer, BigBirdTokenizerFast
  from transformers.models.bert.tokenization_bert import load_vocab
  from transformers.tokenization_utils import PreTrainedTokenizer
  from transformers import AutoConfig
  from farm.data_handler.samples import SampleBasket
  from farm.modeling.wordembedding_utils import load_from_cache, EMBEDDING_VOCAB_FILES_MAP, run_split_on_punc
label_desc: Use image node_id 3 for calling a global function with example usage: truncate_sequences(seq_a, seq_b, tokenizer, max_seq_len, truncation_strategy, with_special_tokens, stride) and returns: seq_a,  seq_b,  overflowing_tokens