class_docstr: Task for WinoGrande dataset. Efficient implementation for Winograd schema
  tasks with exactly two candidates, one of which is correct.
class_docstr_tok: ["Task","for","WinoGrande","dataset",".","Efficient","implementation","for","Winograd","schema","tasks","with","exactly","two","candidates",",","one","of","which","is","correct","."]
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 = []
  
      itr = wsc_utils.winogrande_jsonl_iterator(
          data_path, eval=(split == "test")
      )
  
      for sample in itr:
          sentence, pronoun_span, query, cand_text = sample
          prefix = sentence[: pronoun_span[0]].rstrip()
          suffix = sentence[pronoun_span[1] :]
  
          leading_space = (
              " " if sentence[: pronoun_span[0]].endswith(" ") else ""
          )
          trailing_space = ""
  
          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_mask = self.binarize_with_mask(
              cand_text,
              prefix,
              suffix,
              leading_space,
              trailing_space,
          )
  
          candidate_tokens.append(cand_toks)
          candidate_masks.append(cand_mask)
          candidate_lengths.append(cand_toks.size(0))
  
      query_lengths = np.array(query_lengths)
  
      def get_pad_dataset_fn(tokens, length, pad_idx):
          return PadDataset(
              ListDataset(tokens, length),
              pad_idx=pad_idx,
              left_pad=False,
          )
  
      query_tokens = get_pad_dataset_fn(
          query_tokens, query_lengths, self.vocab.pad()
      )
      query_masks = get_pad_dataset_fn(query_masks, query_lengths, 0)
  
      candidate_lengths = np.array(candidate_lengths)
      candidate_tokens = get_pad_dataset_fn(
          candidate_tokens, candidate_lengths, self.vocab.pad()
      )
      candidate_masks = get_pad_dataset_fn(
          candidate_masks, candidate_lengths, 0
      )
  
      dataset = {
          "id": IdDataset(),
          "query_tokens": query_tokens,
          "query_masks": query_masks,
          "candidate_tokens": candidate_tokens,
          "candidate_masks": candidate_masks,
          "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 2 for calling the WinograndeTask obj's underlying member method code with example usage: obj.load_dataset(split, epoch, combine, data_path, return_only) and returns: self, PadDataset, dataset