text: 
  
  TITLE
  ValueError: too many values to unpack (expected 2) using BERT to training
  
  COMMENTS
  0
  
  REACTIONS
  +1: 0
  -1: 0
  laugh: 0
  hooray: 0
  heart: 0
  rocket: 0
  eyes: 0
  
  BODY
  ### System Info
  
  ```shell
  Preparing the dataset and dataloader and Defining the model but I get this error ValueError: too many values to unpack (expected 2).
  ```
  
  
  ### Who can help?
  
  @LysandreJik, @sgugger
  
  ### Information
  
  - [ ] The official example scripts
  - [ ] My own modified scripts
  
  ### Tasks
  
  - [ ] An officially supported task in the `examples` folder (such as GLUE/SQuAD, ...)
  - [ ] My own task or dataset (give details below)
  
  ### Reproduction
  
  tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased') 
  class dataset(Dataset):
    def __init__(self, dataframe, tokenizer, max_len):
          self.len = len(dataframe)
          self.data = dataframe
          self.tokenizer = tokenizer
          self.max_len = max_len
  
    def __getitem__(self, index):
          # step 1: get the sentence and word labels 
          sentence = self.data.sentence[index].strip().split()  
          word_labels = self.data.word_labels[index].split(",") 
  
          # step 2: use tokenizer to encode sentence (includes padding/truncation up to max length)
          # BertTokenizerFast provides a handy "return_offsets_mapping" functionality for individual tokens
          encoding = self.tokenizer(sentence, 
                               #is_pretokenized=True,
                               return_offsets_mapping=True, 
                               padding='max_length', 
                               truncation=True, 
                               max_length=self.max_len)
          
          # step 3: create token labels only for first word pieces of each tokenized word
          labels = [labels_to_ids[label] for label in word_labels] 
          # code based on https://huggingface.co/transformers/custom_datasets.html#tok-ner
          # create an empty array of -100 of length max_length
          encoded_labels = np.ones(len(encoding["offset_mapping"]), dtype=int) * -100
          
          # set only labels whose first offset position is 0 and the second is not 0
          i = 0
          for idx, mapping in enumerate(encoding["offset_mapping"]):
            if mapping[0] == 0 and mapping[1] != 0:
              # overwrite label
              encoded_labels[idx] = labels[i]
              i += 1
  
          # step 4: turn everything into PyTorch tensors
          item = {key: torch.as_tensor(val) for key, val in encoding.items()}
          item['labels'] = torch.as_tensor(encoded_labels)
          
          return item
  
    def __len__(self):
          return self.len
  
  
  train_size = 0.8
  train_dataset = data.sample(frac=train_size,random_state=200)
  test_dataset = data.drop(train_dataset.index).reset_index(drop=True)
  train_dataset = train_dataset.reset_index(drop=True)
  
  print("FULL Dataset: {}".format(data.shape))
  print("TRAIN Dataset: {}".format(train_dataset.shape))
  print("TEST Dataset: {}".format(test_dataset.shape))
  
  training_set = dataset(train_dataset, tokenizer, MAX_LEN)
  testing_set = dataset(test_dataset, tokenizer, MAX_LEN)
  
  train_params = {'batch_size': TRAIN_BATCH_SIZE,
                  'shuffle': True,
                  'num_workers': 0
                  }
  
  test_params = {'batch_size': VALID_BATCH_SIZE,
                  'shuffle': True,
                  'num_workers': 0
                  }
  
  training_loader = DataLoader(training_set, **train_params)
  testing_loader = DataLoader(testing_set, **test_params)
  
  model = BertForTokenClassification.from_pretrained('bert-base-uncased', num_labels=len(labels_to_ids))
  model.to(device)
  
  inputs = training_set[2]
  input_ids = inputs["input_ids"].unsqueeze(0)
  attention_mask = inputs["attention_mask"].unsqueeze(0)
  labels = inputs["labels"].unsqueeze(0)
  
  input_ids = input_ids.to(device)
  attention_mask = attention_mask.to(device)
  labels = labels.to(device)
  
  outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
  initial_loss = outputs[0]
  initial_loss
  
  
  
  
  
  
  
  
  
  And here is the error code: 
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  [<ipython-input-31-c8d1cd345a9a>](https://localhost:8080/#) in <module>()
        8 labels = labels.to(device)
        9 
  ---> 10 outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
       11 initial_loss = outputs[0]
       12 initial_loss
  
  3 frames
  [/usr/local/lib/python3.7/dist-packages/transformers/models/bert/modeling_bert.py](https://localhost:8080/#) in forward(self, input_ids, attention_mask, token_type_ids, position_ids, head_mask, inputs_embeds, encoder_hidden_states, encoder_attention_mask, past_key_values, use_cache, output_attentions, output_hidden_states, return_dict)
      948             raise ValueError("You have to specify either input_ids or inputs_embeds")
      949 
  --> 950         batch_size, seq_length = input_shape
      951         device = input_ids.device if input_ids is not None else inputs_embeds.device
      952 
  
  ValueError: too many values to unpack (expected 2)
  
  ### Expected behavior
  
  ```shell
  I will train my NER-BARTmodel
  ```
  