Class Tagger

The tagger must have reference to the grammar being used to parse the input. It must also be given the full input when instantiated. The format of this input will depend on the tagger: for example, it might be a string or a MIDI file.

Parameters:

• original_input - the input in its original, unprocessed form. This will usually be a string. This is optional, but in some circumstances things might fall apart if it hasn't been given. E.g. using a backoff model as backoff from a tagging model requires the original input to be passed to the backoff model.
• logger - optional progress logger. Logging will be sent to this during initialization of the tagger and tagging. If not given, the logging will be lost. Subclasses may access the logger (or a dummy logger if none was given) in self.logger.

Overrides: object.__init__

Normally, options are validated when the tagger is instantiated. This allows you to check them before that.

Gets all signs that the tagger will return, regardless of offset. This just uses get_signs to get the signs for every offset.

Returns: dict

all the signs, keyed by (start,end) tuple

Returns a list of tuples (start, end, signtup). These represent spans to be added to the chart, start and end being the start and end nodes.

Each signtup is a (sign,tag,probability) tuple representing a sign that the tagger wishes to add to the chart in this position. How many are returned is up to the tagger (it may wish to return more in cases where there are no clear winners, for example). If the tag is not found in the grammar, sign will be None.

Returned list is sorted by probability, highest first.

offset may be set >0 in order to retrieve further signs once some have already been returned. If offset=k, the tagger should disregard all the signs that would have been returned for offset<k and return the next bunch - as many as it sees fit. offset is incremented each time the parse fails.

The simplest approach, and that employed by most taggers, has some signs for each word and none spanning more than one word. That is, the tuples in the list would be of the form (wordnum, wordnum+1, signtup). This is by no means required, though: some taggers will want to add multi-node spans to the chart.

Returns a list of string representations of the inputs. This is just a convenience function, which uses whatever representation gets returned by get_word() to produce a representation of the whole input.

Returns as a float the probability with which the tagger judges the given span will be assigned the given sign.

If end_index is not given, it defaults to index+1.

Returns the input word at this index. This does not need to be a string, but must have a sensible __str__, so that it can be converted to a readable string. The purpose of this is to provide a readable form of the input for the parser to store in derivation traces.

Returns the duration of the word at this index if durations are available. Otherwise raises an AttributeError.

INPUT_TYPES

List of allowed input datatypes. See jazzparser.data.input.INPUT_TYPES.

Value:

[]

LEXICAL_PROBABILITY

Some models provide lexical probabilities that the parsing models can use. They should set this to true. They should also provide a method lexical_probability(start_time, end_time, span_label).

Value:

False

TAGGER_OPTIONS

Tagger-specific options. List of ModuleOptions.

Value:

[]

input_length

Should return the number of words (chords) in the input, or some other measure of input length appropriate to the type of tagger.

Get Method:

_get_input_length(self) - Should return the number of words (chords) in the input, or some other measure of input length appropriate to the type of tagger.

name

Get Method:

_get_name(self)