class_docstr: Task to finetune RoBERTa for Winograd Schemas.
class_docstr_tok: ["Task","to","finetune","RoBERTa","for","Winograd","Schemas","."]
docstr: Load a given dataset split.
  
  Args:
      split (str): name of the split (e.g., train, valid, test)
docstr_tok: ["Load","a","given","dataset","split",".","Args",":","split","(","str",")",":","name","of","the","split","(","e.g.",",","train",",","valid",",","test",")"]
code: def load_dataset(
      self,
      split,
      epoch=1,
      combine=False,
      data_path=None,
      return_only=False,
      **kwargs,
  ):
      """Load a given dataset split.
  
      Args:
          split (str): name of the split (e.g., train, valid, test)
      """
      if data_path is None:
          data_path = os.path.join(self.args.data, split + ".jsonl")
      if not os.path.exists(data_path):
          raise FileNotFoundError(
              "Cannot find data: {}".format(data_path)
          )
  
      query_tokens = []
      query_masks = []
      query_lengths = []
      candidate_tokens = []
      candidate_masks = []
      candidate_lengths = []
      labels = []
  
      for (
          sentence,
          pronoun_span,
          query,
          label,
      ) in wsc_utils.jsonl_iterator(data_path):
          prefix = sentence[: pronoun_span.start].text
          suffix = sentence[pronoun_span.end :].text_with_ws
  
          # spaCy spans include trailing spaces, but we need to know about
          # leading spaces for the GPT-2 BPE
          leading_space = (
              " "
              if sentence[: pronoun_span.start].text_with_ws.endswith(
                  " "
              )
              else ""
          )
          trailing_space = (
              " " if pronoun_span.text_with_ws.endswith(" ") else ""
          )
  
          # get noun phrases, excluding pronouns and anything overlapping with the query
          cand_spans = wsc_utils.filter_noun_chunks(
              wsc_utils.extended_noun_chunks(sentence),
              exclude_pronouns=True,
              exclude_query=query,
              exact_match=False,
          )
  
          if query is not None:
              query_toks, query_mask = self.binarize_with_mask(
                  query, prefix, suffix, leading_space, trailing_space
              )
              query_len = len(query_toks)
          else:
              query_toks, query_mask, query_len = None, None, 0
  
          query_tokens.append(query_toks)
          query_masks.append(query_mask)
          query_lengths.append(query_len)
  
          cand_toks, cand_masks = [], []
          for cand_span in cand_spans:
              toks, mask = self.binarize_with_mask(
                  cand_span.text,
                  prefix,
                  suffix,
                  leading_space,
                  trailing_space,
              )
              cand_toks.append(toks)
              cand_masks.append(mask)
  
          # collate candidates
          cand_toks = data_utils.collate_tokens(
              cand_toks, pad_idx=self.vocab.pad()
          )
          cand_masks = data_utils.collate_tokens(cand_masks, pad_idx=0)
          assert cand_toks.size() == cand_masks.size()
  
          candidate_tokens.append(cand_toks)
          candidate_masks.append(cand_masks)
          candidate_lengths.append(cand_toks.size(1))
  
          labels.append(label)
  
      query_lengths = np.array(query_lengths)
      query_tokens = ListDataset(query_tokens, query_lengths)
      query_masks = ListDataset(query_masks, query_lengths)
  
      candidate_lengths = np.array(candidate_lengths)
      candidate_tokens = ListDataset(
          candidate_tokens, candidate_lengths
      )
      candidate_masks = ListDataset(candidate_masks, candidate_lengths)
  
      labels = ListDataset(labels, [1] * len(labels))
  
      dataset = {
          "id": IdDataset(),
          "query_tokens": query_tokens,
          "query_masks": query_masks,
          "candidate_tokens": candidate_tokens,
          "candidate_masks": candidate_masks,
          "labels": labels,
          "nsentences": NumSamplesDataset(),
          "ntokens": NumelDataset(query_tokens, reduce=True),
      }
  
      nested_dataset = NestedDictionaryDataset(
          dataset,
          sizes=[query_lengths],
      )
  
      with data_utils.numpy_seed(self.args.seed):
          shuffle = np.random.permutation(len(query_tokens))
      dataset = SortDataset(
          nested_dataset,
          # shuffle
          sort_order=[shuffle],
      )
  
      if return_only:
          return dataset
  
      self.datasets[split] = dataset
      return self.datasets[split]
  
imports: import json
  import os
  import tempfile
  import numpy
  import torch
  import torch.nn.functional
  from fairseq import utils
  from fairseq.data import Dictionary, IdDataset, ListDataset, NestedDictionaryDataset, NumelDataset, NumSamplesDataset, PadDataset, SortDataset, data_utils, encoders
  from fairseq.tasks import LegacyFairseqTask, register_task
  from .None import wsc_utils
label_desc: Use image node_id 7 for calling the WSCTask obj's underlying member method code with example usage: obj.load_dataset(split, epoch, combine, data_path, return_only) and returns: self, dataset