How to load custom reader and predictor using code

[skasim]

I am new AllenNLP and PyTorch. I want to use the crf_tagger model and output results that include the token start and end offsets. Following @matt-gardner's advice, I implemented a custom reader and predictor and use the fine-grained-ner.2021-01-11 model. I can run it with the allennlp predict command in the command-line and get the results I want.

However, I am trying to implement this using code instead of running in terminal with command-line, but I am not able to access my custom classes without directly instantiating them and I get errors whether I directly instantiate the custom classes or try to add them as the default_implementation . I want to know how I can get the same results using code as I do with the command line. More specifically, I think my issue is that I am not loading the custom classes correctly causing the errors. I'd appreciate any help.

Command line argument:

allennlp predict \
  --output-file run_output.json \
  --include-package tagging \
  --predictor allennlp_raw_text_predictor \
  --use-dataset-reader \
  --silent \
  .../allennlp/fine-grained-ner.2021-02-11/ \
  data/article.txt

Reader:

@DatasetReader.register("allennlp_raw_text_reader")
class AllenNLPRawTextReader(DatasetReader):
    DatasetReader.default_implementation = "allennlp_raw_text_reader"

    def __init__(self,
                 token_indexers: Dict[str, TokenIndexer] = None) -> None:
        super().__init__()
        self.tokenizer = SpacyTokenizer()
        self._token_indexers = token_indexers or {"elmo": ELMoTokenCharactersIndexer(),
                                                  "token_characters": TokenCharactersIndexer(min_padding_length=4),
                                                  "tokens": SingleIdTokenIndexer()}

    @overrides
    def _read(self, file_path: str) -> Instance:
        with open(file_path, "r") as f:
            text = f.read()
            tokens = self.tokenizer.tokenize(text)
            yield self.text_to_instance(tokens)

    @overrides
    def text_to_instance(self,
                         words: List[Token],
                         ) -> Instance:
        # wrap each token in the file with a token object
        tokens = TextField(tokens=words, token_indexers=self._token_indexers)
        fields = {"tokens": tokens}
        return Instance(fields=fields)

and the predictor:

@Predictor.register("allennlp_raw_text_predictor")
class AllenNLPRawTextPredictor(Predictor):
    Predictor.default_implementation = "allennlp_raw_text_predictor"

    def predict_instance(self, instance: Instance) -> JsonDict:
        outputs = self._model.forward_on_instance(instance)
        label_vocab = self._model.vocab.get_index_to_token_vocabulary('labels')

        tokens = []
        for token in instance.fields['tokens'].tokens:
            t = token
            tokens.append({"token": t, "start": t.idx, "end": t.idx_end})
        outputs["tokens"] = tokens
        predicted = [label_vocab[l] for l in outputs['logits'].argmax(1)]

        assert len(predicted) == len(outputs["tokens"])

        for i in range(0, len(predicted)):
            outputs["tokens"][i]["tag"] = predicted[i]
        return sanitize(outputs["tokens"])

In a separate runner.py file, I try to run the code. I instantiate the custom reader and predictor directly like below. I can output an Instance object from the reader, but then when the Instance object is passed predictor.predict_instance(instance=instance), there is a TypeError downstream.

cfg_file = ".../allennlp_ner/configs/fine-grained/config.json"
article = ".../allennlp_ner/data/article.txt"
model_dir = ".../fine-grained-ner.2021-02-11"
weights_file = ".../fine-grained-ner.2021-02-11/weights.th"

reader = DatasetReader()
reader.from_params(params=Params.from_file(cfg_file).get("dataset_reader"))
print(f"READERS AVAILABLE: {reader.list_available()}")
instance = reader.read(file_path=article)

reader = AllenNLPRawTextReader()
instance = reader.read(file_path=article)
for i in instance:
    instance = Instance(i)

vocab = Vocabulary()
model = Model(vocab=vocab, serialization_dir=model_dir)
print(f"MODELS AVAILABLE: {model.list_available()}")

model.load(config=Params.from_file(cfg_file), serialization_dir=model_dir, weights_file=weights_file)
predictor = AllenNLPRawTextPredictor(model=model, dataset_reader=reader)
print(f"PREDICTORS AVAILABLE: {predictor.list_available()}")
outputs = predictor.predict_instance(instance=instance)

Traceback (most recent call last):
  File "/allennlp_ner/runner.py", line 60, in <module>
    outputs = predictor.predict_instance(instance=instance)
  File "/allennlp_ner/tagging/predictors/raw_text_predictor.py", line 12, in predict_instance
    outputs = self._model.forward_on_instance(instance)
  File "/opt/anaconda3/envs/tagging/lib/python3.8/site-packages/allennlp/models/model.py", line 172, in forward_on_instance
    return self.forward_on_instances([instance])[0]
  File "/opt/anaconda3/envs/tagging/lib/python3.8/site-packages/allennlp/models/model.py", line 198, in forward_on_instances
    outputs = self.make_output_human_readable(self(**model_input))
  File "/opt/anaconda3/envs/tagging/lib/python3.8/site-packages/torch/nn/modules/module.py", line 891, in _call_impl
    result = self.forward(*input, **kwargs)
TypeError: forward() got an unexpected keyword argument 'tokens'

My config.json

{
    "dataset_reader": {
        "type": "allennlp_raw_text_reader",
        "token_indexers": {
            "elmo": {
                "type": "elmo_characters"
            },
            "token_characters": {
                "type": "characters"
            },
            "tokens": {
                "type": "single_id",
                "lowercase_tokens": true
            }
        }
    },
    "model": {
        "type": "crf_tagger",
        "dropout": 0.5,
        "encoder": {
            "type": "stacked_bidirectional_lstm",
            "hidden_size": 200,
            "input_size": 1202,
            "num_layers": 2,
            "recurrent_dropout_probability": 0.5,
            "use_highway": true
        },
        "feedforward": {
            "activations": "tanh",
            "dropout": 0.5,
            "hidden_dims": 400,
            "input_dim": 400,
            "num_layers": 1
        },
        "include_start_end_transitions": false,
        "initializer": {
            "regexes": [
                [
                    ".*tag_projection_layer.*weight",
                    {
                        "type": "xavier_uniform"
                    }
                ],
                [
                    ".*tag_projection_layer.*bias",
                    {
                        "type": "zero"
                    }
                ],
                [
                    ".*feedforward.*weight",
                    {
                        "type": "xavier_uniform"
                    }
                ],
                [
                    ".*feedforward.*bias",
                    {
                        "type": "zero"
                    }
                ],
                [
                    ".*weight_ih.*",
                    {
                        "type": "xavier_uniform"
                    }
                ],
                [
                    ".*weight_hh.*",
                    {
                        "type": "orthogonal"
                    }
                ],
                [
                    ".*bias_ih.*",
                    {
                        "type": "zero"
                    }
                ],
                [
                    ".*bias_hh.*",
                    {
                        "type": "lstm_hidden_bias"
                    }
                ]
            ]
        },
        "label_encoding": "BIOUL",
        "regularizer": {
            "regexes": [
                [
                    "scalar_parameters",
                    {
                        "alpha": 0.001,
                        "type": "l2"
                    }
                ]
            ]
        },
        "text_field_embedder": {
            "token_embedders": {
                "elmo": {
                    "type": "elmo_token_embedder",
                    "do_layer_norm": false,
                    "dropout": 0
                },
                "token_characters": {
                    "type": "character_encoding",
                    "embedding": {
                        "embedding_dim": 25,
                        "sparse": true,
                        "vocab_namespace": "token_characters"
                    },
                    "encoder": {
                        "type": "lstm",
                        "hidden_size": 128,
                        "input_size": 25,
                        "num_layers": 1
                    }
                },
                "tokens": {
                    "type": "embedding",
                    "embedding_dim": 50,
                    "pretrained_file": "https://allennlp.s3.amazonaws.com/datasets/glove/glove.6B.50d.txt.gz",
                    "sparse": true,
                    "trainable": true
                }
            }
        },
        "verbose_metrics": true
    },
    "train_data_path": "/mnt/tank/dirkg/data/conll-formatted-ontonotes-5.0/data/train",
    "validation_data_path": "/mnt/tank/dirkg/data/conll-formatted-ontonotes-5.0/data/development",
    "trainer": {
        "grad_norm": 5,
        "num_epochs": 30,
        "optimizer": {
            "type": "dense_sparse_adam",
            "lr": 0.001
        },
        "patience": 25,
        "validation_metric": "+f1-measure-overall"
    },
    "data_loader": {
        "batch_sampler": {
            "type": "bucket",
            "batch_size": 64
        }
    }
}

[skasim]

I figured out a solution. The crf_tagger Model was not loading from the serialization_dir when running with custom code, so now I am loading the model directly from archive:

import allennlp_models.tagging as tagging

raw_reader = AllenNLPRawTextReader()
instance = Instance(list(raw_reader.read(file_path=article))[0])
model = tagging.CrfTagger.from_archive(archive_file="https://storage.googleapis.com/allennlp-public-models/fine-grained-ner.2021-02-11.tar.gz")
predictor = AllenNLPRawTextPredictor(model=model, dataset_reader=raw_reader, frozen=False)
outputs = predictor.predict_instance(instance=instance)

[epwalsh]

Glad you got it working!