              losses.setdefault(self.name, 0.0)
              losses[self.name] += (gradient**2).sum()
  
      def get_loss(self, examples, scores):
          scores = self.model.ops.flatten(scores)
          tag_index = {tag: i for i, tag in enumerate(self.labels)}
          cdef int idx = 0
          correct = numpy.zeros((scores.shape[0],), dtype="i")
          guesses = scores.argmax(axis=1)
          known_labels = numpy.ones((scores.shape[0], 1), dtype="f")
          for ex in examples:
              gold = ex.gold
              for tag in gold.tags:
                  if tag is None:
                      correct[idx] = guesses[idx]
                  elif tag in tag_index:
                      correct[idx] = tag_index[tag]
                  else:
                      correct[idx] = 0
                      known_labels[idx] = 0.
                  idx += 1
          correct = self.model.ops.xp.array(correct, dtype="i")
          d_scores = scores - to_categorical(correct, n_classes=scores.shape[1])
          d_scores *= self.model.ops.asarray(known_labels)
          loss = (d_scores**2).sum()
          docs = [ex.doc for ex in examples]
          d_scores = self.model.ops.unflatten(d_scores, [len(d) for d in docs])
          return float(loss), d_scores
  
      def begin_training(self, get_examples=lambda: [], pipeline=None, sgd=None,
                         **kwargs):
          lemma_tables = ["lemma_rules", "lemma_index", "lemma_exc", "lemma_lookup"]
 
</s> remove             n_words = sum(len(ex.doc) for ex in dev_examples)
            start_time = timer()
            scorer = nlp.evaluate(dev_examples)
            end_time = timer()
            wps = n_words / (end_time - start_time)
            scores = scorer.scores
            # Calculate a weighted sum based on score_weights for the main score
            weights = cfg["score_weights"]
            weighted_score = sum(scores[s] * weights.get(s, 0.0) for s in weights)
            scores["speed"] = wps
 </s> add         )
        n_words = sum(len(ex.doc) for ex in dev_examples)
        start_time = timer()
            
        if optimizer.averages:
            with nlp.use_params(optimizer.averages):
                scorer = nlp.evaluate(dev_examples, batch_size=32)
        else:
            scorer = nlp.evaluate(dev_examples, batch_size=32)
        end_time = timer()
        wps = n_words / (end_time - start_time)
        scores = scorer.scores
        # Calculate a weighted sum based on score_weights for the main score
        weights = cfg["score_weights"]
        weighted_score = sum(scores[s] * weights.get(s, 0.0) for s in weights)
        scores["speed"] = wps </s> remove def subdivide_batch(batch):
    return [batch]
 </s> add def subdivide_batch(batch, accumulate_gradient):
    batch = list(batch)
    batch.sort(key=lambda eg: len(eg.doc))
    sub_len = len(batch) // accumulate_gradient
    start = 0
    for i in range(accumulate_gradient):
        subbatch = batch[start : start + sub_len]
        if subbatch:
            yield subbatch
        start += len(subbatch)
    subbatch = batch[start : ]
    if subbatch:
        yield subbatch </s> remove     if model.vec2scores is not None:
 </s> add     if model.attrs["has_upper"]: </s> remove         if self.vec2scores is None:
            self._class_mask = numpy.zeros((self.state2vec.nO,), dtype='f')
        else:
            self._class_mask = numpy.zeros((self.vec2scores.get_dim("nO"),), dtype='f')
 </s> add         self._class_mask = numpy.zeros((self.nO,), dtype='f')
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
              losses.setdefault(self.name, 0.0)
              losses[self.name] += (gradient**2).sum()
  
      def get_loss(self, examples, scores):
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
        loss_func = SequenceCategoricalCrossentropy(names=self.labels)
        truths = [eg.gold.tags for eg in examples]
        d_scores, loss = loss_func(scores, truths)
        if self.model.ops.xp.isnan(loss):
            raise ValueError("nan value when computing loss")
          return float(loss), d_scores
  
      def begin_training(self, get_examples=lambda: [], pipeline=None, sgd=None,
                         **kwargs):
          lemma_tables = ["lemma_rules", "lemma_index", "lemma_exc", "lemma_lookup"]
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Adapt parser and NER for transformers (#5449)

* Draft layer for BILUO actions

* Fixes to biluo layer

* WIP on BILUO layer

* Add tests for BILUO layer

* Format

* Fix transitions

* Update test

* Link in the simple_ner

* Update BILUO tagger

* Update __init__

* Import simple_ner

* Update test

* Import

* Add files

* Add config

* Fix label passing for BILUO and tagger

* Fix label handling for simple_ner component

* Update simple NER test

* Update config

* Hack train script

* Update BILUO layer

* Fix SimpleNER component

* Update train_from_config

* Add biluo_to_iob helper

* Add IOB layer

* Add IOBTagger model

* Update biluo layer

* Update SimpleNER tagger

* Update BILUO

* Read random seed in train-from-config

* Update use of normal_init

* Fix normalization of gradient in SimpleNER

* Update IOBTagger

* Remove print

* Tweak masking in BILUO

* Add dropout in SimpleNER

* Update thinc

* Tidy up simple_ner

* Fix biluo model

* Unhack train-from-config

* Update setup.cfg and requirements

* Add tb_framework.py for parser model

* Try to avoid memory leak in BILUO

* Move ParserModel into spacy.ml, avoid need for subclass.

* Use updated parser model

* Remove incorrect call to model.initializre in PrecomputableAffine

* Update parser model

* Avoid divide by zero in tagger

* Add extra dropout layer in tagger

* Refine minibatch_by_words function to avoid oom

* Fix parser model after refactor

* Try to avoid div-by-zero in SimpleNER

* Fix infinite loop in minibatch_by_words

* Use SequenceCategoricalCrossentropy in Tagger

* Fix parser model when hidden layer

* Remove extra dropout from tagger

* Add extra nan check in tagger

* Fix thinc version

* Update tests and imports

* Fix test

* Update test

* Update tests

* Fix tests

* Fix test

Co-authored-by: Ines Montani <ines@ines.io> 
spacy/pipeline/pipes.pyx