          cfg = json.load(open(path.join(model_dir, 'config.json')))
          templates = cfg['templates']
          self.entity_types = cfg['entity_types']
          self.extractor = Extractor(templates, [ConjFeat] * len(templates))
          self.n_classes = get_n_moves(len(self.entity_types))
          self._moves = <Move*>self.mem.alloc(self.n_classes, sizeof(Move))
          fill_moves(self._moves, len(self.entity_types))
          self.model = LinearModel(len(self.tag_names))
          if path.exists(path.join(model_dir, 'model')):
              self.model.load(path.join(model_dir, 'model'))
  
          self._context = <atom_t*>self.mem.alloc(N_FIELDS, sizeof(atom_t))
          self._feats = <feat_t*>self.mem.alloc(self.extractor.n+1, sizeof(feat_t))
 
</s> remove         self.entity_types = cfg['entity_types']
 </s> add         self.tag_names = cfg['tag_names'] </s> remove     cpdef int train(self, Tokens tokens, gold_classes):
 </s> add     cpdef int train(self, Tokens tokens, gold_classes) except -1: </s> remove     cdef weight_t score = scores[first_accept]
 </s> add     cdef weight_t score = scores[first_accept-1] </s> remove         for i, clas in enumerate(gold_classes):
            golds[i] = self.moves[clas - 1]
            assert golds[i].id == clas
 </s> add         for tok_i, clas in enumerate(gold_classes):
            golds[tok_i] = self._moves[clas]
            assert golds[tok_i].clas == clas, '%d vs %d' % (golds[tok_i].clas, clas)
        self.n_classes = len(self.tag_names)
        self._moves = <Move*>self.mem.alloc(len(self.tag_names), sizeof(Move))
        fill_moves(self._moves, self.tag_names)
        self.model = LinearModel(self.n_classes)
          cfg = json.load(open(path.join(model_dir, 'config.json')))
          templates = cfg['templates']
          self.entity_types = cfg['entity_types']
          self.extractor = Extractor(templates, [ConjFeat] * len(templates))
        self.n_classes = len(self.tag_names)
        self._moves = <Move*>self.mem.alloc(len(self.tag_names), sizeof(Move))
        fill_moves(self._moves, self.tag_names)
        self.model = LinearModel(self.n_classes)
        self.n_classes = len(self.tag_names)
        self._moves = <Move*>self.mem.alloc(len(self.tag_names), sizeof(Move))
        fill_moves(self._moves, self.tag_names)
        self.model = LinearModel(self.n_classes)
        self.n_classes = len(self.tag_names)
        self._moves = <Move*>self.mem.alloc(len(self.tag_names), sizeof(Move))
        fill_moves(self._moves, self.tag_names)
        self.model = LinearModel(self.n_classes)
        self.n_classes = len(self.tag_names)
        self._moves = <Move*>self.mem.alloc(len(self.tag_names), sizeof(Move))
        fill_moves(self._moves, self.tag_names)
        self.model = LinearModel(self.n_classes)
          if path.exists(path.join(model_dir, 'model')):
              self.model.load(path.join(model_dir, 'model'))
  
          self._context = <atom_t*>self.mem.alloc(N_FIELDS, sizeof(atom_t))
          self._feats = <feat_t*>self.mem.alloc(self.extractor.n+1, sizeof(feat_t))
keep keep keep keep replace replace replace replace keep keep keep keep keep
 * Fixed greedy NER parsing. With static oracle, replicates accuracy from tagger. 
spacy/ner/greedy_parser.pyx