# Natural Language Toolkit: Regexp Chunk Parser Application
#
# Copyright (C) 2001-2013 NLTK Project
# Author: Edward Loper <edloper@gmail.com>
# URL: <http://nltk.org/>
# For license information, see LICENSE.TXT
"""
A graphical tool for exploring the regular expression based chunk
parser ``nltk.chunk.RegexpChunkParser``.
"""
# Todo: Add a way to select the development set from the menubar. This
# might just need to be a selection box (conll vs treebank etc) plus
# configuration parameters to select what's being chunked (eg VP vs NP)
# and what part of the data is being used as the development set.
import nltk.compat
import time
import textwrap
import re
import random
import tkinter.filedialog, tkinter.font
from tkinter import (Button, Canvas, Checkbutton,
Frame, IntVar, Label, Menu,
Scrollbar, Text, Tk)
from nltk.tree import Tree
from nltk.util import in_idle
from nltk.draw.util import ShowText
from nltk.corpus import conll2000, treebank_chunk
from nltk.chunk import ChunkScore, RegexpChunkParser
from nltk.chunk.regexp import RegexpChunkRule
class RegexpChunkApp(object):
"""
A graphical tool for exploring the regular expression based chunk
parser ``nltk.chunk.RegexpChunkParser``.
See ``HELP`` for instructional text.
"""
##/////////////////////////////////////////////////////////////////
## Help Text
##/////////////////////////////////////////////////////////////////
#: A dictionary mapping from part of speech tags to descriptions,
#: which is used in the help text. (This should probably live with
#: the conll and/or treebank corpus instead.)
TAGSET = {
'CC': 'Coordinating conjunction', 'PRP$': 'Possessive pronoun',
'CD': 'Cardinal number', 'RB': 'Adverb',
'DT': 'Determiner', 'RBR': 'Adverb, comparative',
'EX': 'Existential there', 'RBS': 'Adverb, superlative',
'FW': 'Foreign word', 'RP': 'Particle',
'JJ': 'Adjective', 'TO': 'to',
'JJR': 'Adjective, comparative', 'UH': 'Interjection',
'JJS': 'Adjective, superlative', 'VB': 'Verb, base form',
'LS': 'List item marker', 'VBD': 'Verb, past tense',
'MD': 'Modal', 'NNS': 'Noun, plural',
'NN': 'Noun, singular or masps', 'VBN': 'Verb, past participle',
'VBZ': 'Verb,3rd ps. sing. present', 'NNP': 'Proper noun, singular',
'NNPS': 'Proper noun plural', 'WDT': 'wh-determiner',
'PDT': 'Predeterminer', 'WP': 'wh-pronoun',
'POS': 'Possessive ending', 'WP$': 'Possessive wh-pronoun',
'PRP': 'Personal pronoun', 'WRB': 'wh-adverb',
'(': 'open parenthesis', ')': 'close parenthesis',
'``': 'open quote', ',': 'comma',
"''": 'close quote', '.': 'period',
'#': 'pound sign (currency marker)',
'$': 'dollar sign (currency marker)',
'IN': 'Preposition/subord. conjunction',
'SYM': 'Symbol (mathematical or scientific)',
'VBG': 'Verb, gerund/present participle',
'VBP': 'Verb, non-3rd ps. sing. present',
':': 'colon',
}
#: Contents for the help box. This is a list of tuples, one for
#: each help page, where each tuple has four elements:
#: - A title (displayed as a tab)
#: - A string description of tabstops (see Tkinter.Text for details)
#: - The text contents for the help page. You can use expressions
#: like <red>...</red> to colorize the text; see ``HELP_AUTOTAG``
#: for a list of tags you can use for colorizing.
HELP = [
('Help', '20',
"Welcome to the regular expression chunk-parser grammar editor. "
"You can use this editor to develop and test chunk parser grammars "
"based on NLTK's RegexpChunkParser class.\n\n"
# Help box.
"Use this box ('Help') to learn more about the editor; click on the "
"tabs for help on specific topics:"
"<indent>\n"
"Rules: grammar rule types\n"
"Regexps: regular expression syntax\n"
"Tags: part of speech tags\n</indent>\n"
# Grammar.
"Use the upper-left box ('Grammar') to edit your grammar. "
"Each line of your grammar specifies a single 'rule', "
"which performs an action such as creating a chunk or merging "
"two chunks.\n\n"
# Dev set.
"The lower-left box ('Development Set') runs your grammar on the "
"development set, and displays the results. "
"Your grammar's chunks are <highlight>highlighted</highlight>, and "
"the correct (gold standard) chunks are "
"<underline>underlined</underline>. If they "
"match, they are displayed in <green>green</green>; otherwise, "
"they are displayed in <red>red</red>. The box displays a single "
"sentence from the development set at a time; use the scrollbar or "
"the next/previous buttons view additional sentences.\n\n"
# Performance
"The lower-right box ('Evaluation') tracks the performance of "
"your grammar on the development set. The 'precision' axis "
"indicates how many of your grammar's chunks are correct; and "
"the 'recall' axis indicates how many of the gold standard "
"chunks your system generated. Typically, you should try to "
"design a grammar that scores high on both metrics. The "
"exact precision and recall of the current grammar, as well "
"as their harmonic mean (the 'f-score'), are displayed in "
"the status bar at the bottom of the window."
),
('Rules', '10',
"<h1>{...regexp...}</h1>"
"<indent>\nChunk rule: creates new chunks from words matching "
"regexp.</indent>\n\n"
"<h1>}...regexp...{</h1>"
"<indent>\nChink rule: removes words matching regexp from existing "
"chunks.</indent>\n\n"
"<h1>...regexp1...}{...regexp2...</h1>"
"<indent>\nSplit rule: splits chunks that match regexp1 followed by "
"regexp2 in two.</indent>\n\n"
"<h1>...regexp...{}...regexp...</h1>"
"<indent>\nMerge rule: joins consecutive chunks that match regexp1 "
"and regexp2</indent>\n"
),
('Regexps', '10 60',
#"Regular Expression Syntax Summary:\n\n"
"<h1>Pattern\t\tMatches...</h1>\n"
"<hangindent>"
"\t<<var>T</var>>\ta word with tag <var>T</var> "
"(where <var>T</var> may be a regexp).\n"
"\t<var>x</var>?\tan optional <var>x</var>\n"
"\t<var>x</var>+\ta sequence of 1 or more <var>x</var>'s\n"
"\t<var>x</var>*\ta sequence of 0 or more <var>x</var>'s\n"
"\t<var>x</var>|<var>y</var>\t<var>x</var> or <var>y</var>\n"
"\t.\tmatches any character\n"
"\t(<var>x</var>)\tTreats <var>x</var> as a group\n"
"\t# <var>x...</var>\tTreats <var>x...</var> "
"(to the end of the line) as a comment\n"
"\t\\<var>C</var>\tmatches character <var>C</var> "
"(useful when <var>C</var> is a special character "
"like + or #)\n"
"</hangindent>"
"\n<h1>Examples:</h1>\n"
"<hangindent>"
'\t<regexp><NN></regexp>\n'
'\t\tMatches <match>"cow/NN"</match>\n'
'\t\tMatches <match>"green/NN"</match>\n'
'\t<regexp><VB.*></regexp>\n'
'\t\tMatches <match>"eating/VBG"</match>\n'
'\t\tMatches <match>"ate/VBD"</match>\n'
'\t<regexp><IN><DT><NN></regexp>\n'
'\t\tMatches <match>"on/IN the/DT car/NN"</match>\n'
'\t<regexp><RB>?<VBD></regexp>\n'
'\t\tMatches <match>"ran/VBD"</match>\n'
'\t\tMatches <match>"slowly/RB ate/VBD"</match>\n'
'\t<regexp><\#><CD> # This is a comment...</regexp>\n'
'\t\tMatches <match>"#/# 100/CD"</match>\n'
"</hangindent>"
),
('Tags', '10 60',
"<h1>Part of Speech Tags:</h1>\n" +
'<hangindent>' +
'<<TAGSET>>' + # this gets auto-substituted w/ self.TAGSET
'</hangindent>\n')
]
HELP_AUTOTAG = [
('red', dict(foreground='#a00')),
('green', dict(foreground='#080')),
('highlight', dict(background='#ddd')),
('underline', dict(underline=True)),
('h1', dict(underline=True)),
('indent', dict(lmargin1=20, lmargin2=20)),
('hangindent', dict(lmargin1=0, lmargin2=60)),
('var', dict(foreground='#88f')),
('regexp', dict(foreground='#ba7')),
('match', dict(foreground='#6a6')),
]
##/////////////////////////////////////////////////////////////////
## Config Parmeters
##/////////////////////////////////////////////////////////////////
_EVAL_DELAY = 1
"""If the user has not pressed any key for this amount of time (in
seconds), and the current grammar has not been evaluated, then
the eval demon will evaluate it."""
_EVAL_CHUNK = 15
"""The number of sentences that should be evaluated by the eval
demon each time it runs."""
_EVAL_FREQ = 0.2
"""The frequency (in seconds) at which the eval demon is run"""
_EVAL_DEMON_MIN = .02
"""The minimum amount of time that the eval demon should take each time
it runs -- if it takes less than this time, _EVAL_CHUNK will be
modified upwards."""
_EVAL_DEMON_MAX = .04
"""The maximum amount of time that the eval demon should take each time
it runs -- if it takes more than this time, _EVAL_CHUNK will be
modified downwards."""
_GRAMMARBOX_PARAMS = dict(
width=40, height=12, background='#efe', highlightbackground='#efe',
highlightthickness=1, relief='groove', border=2, wrap='word')
_HELPBOX_PARAMS = dict(
width=15, height=15, background='#efe', highlightbackground='#efe',
foreground='#555',
highlightthickness=1, relief='groove', border=2, wrap='word')
_DEVSETBOX_PARAMS = dict(
width=70, height=10, background='#eef', highlightbackground='#eef',
highlightthickness=1, relief='groove', border=2, wrap='word',
tabs=(30,))
_STATUS_PARAMS = dict(
background='#9bb', relief='groove', border=2)
_FONT_PARAMS = dict(
family='helvetica', size=-20)
_FRAME_PARAMS = dict(
background='#777', padx=2, pady=2, border=3)
_EVALBOX_PARAMS = dict(
background='#eef', highlightbackground='#eef',
highlightthickness=1, relief='groove', border=2,
width=300, height=280)
_BUTTON_PARAMS = dict(
background='#777', activebackground='#777',
highlightbackground='#777')
_HELPTAB_BG_COLOR = '#aba'
_HELPTAB_FG_COLOR = '#efe'
_HELPTAB_FG_PARAMS = dict(background='#efe')
_HELPTAB_BG_PARAMS = dict(background='#aba')
_HELPTAB_SPACER = 6
def normalize_grammar(self, grammar):
# Strip comments
grammar = re.sub(r'((\\.|[^#])*)(#.*)?', r'\1', grammar)
# Normalize whitespace
grammar = re.sub(' +', ' ', grammar)
grammar = re.sub('\n\s+', '\n', grammar)
grammar = grammar.strip()
# [xx] Hack: automatically backslash $!
grammar = re.sub(r'([^\\])\$', r'\1\\$', grammar)
return grammar
def __init__(self, devset_name='conll2000', devset=None,
grammar = '', chunk_label='NP', tagset=None):
"""
:param devset_name: The name of the development set; used for
display & for save files. If either the name 'treebank'
or the name 'conll2000' is used, and devset is None, then
devset will be set automatically.
:param devset: A list of chunked sentences
:param grammar: The initial grammar to display.
:param tagset: Dictionary from tags to string descriptions, used
for the help page. Defaults to ``self.TAGSET``.
"""
self._chunk_label = chunk_label
if tagset is None: tagset = self.TAGSET
self.tagset = tagset
# Named development sets:
if devset is None:
if devset_name == 'conll2000':
devset = conll2000.chunked_sents('train.txt')#[:100]
elif devset == 'treebank':
devset = treebank_chunk.chunked_sents()#[:100]
else:
raise ValueError('Unknown development set %s' % devset_name)
self.chunker = None
"""The chunker built from the grammar string"""
self.grammar = grammar
"""The unparsed grammar string"""
self.normalized_grammar = None
"""A normalized version of ``self.grammar``."""
self.grammar_changed = 0
"""The last time() that the grammar was changed."""
self.devset = devset
"""The development set -- a list of chunked sentences."""
self.devset_name = devset_name
"""The name of the development set (for save files)."""
self.devset_index = -1
"""The index into the development set of the first instance
that's currently being viewed."""
self._last_keypress = 0
"""The time() when a key was most recently pressed"""
self._history = []
"""A list of (grammar, precision, recall, fscore) tuples for
grammars that the user has already tried."""
self._history_index = 0
"""When the user is scrolling through previous grammars, this
is used to keep track of which grammar they're looking at."""
self._eval_grammar = None
"""The grammar that is being currently evaluated by the eval
demon."""
self._eval_normalized_grammar = None
"""A normalized copy of ``_eval_grammar``."""
self._eval_index = 0
"""The index of the next sentence in the development set that
should be looked at by the eval demon."""
self._eval_score = ChunkScore(chunk_label=chunk_label)
"""The ``ChunkScore`` object that's used to keep track of the score
of the current grammar on the development set."""
# Set up the main window.
top = self.top = Tk()
top.geometry('+50+50')
top.title('Regexp Chunk Parser App')
top.bind('<Control-q>', self.destroy)
# Varaible that restricts how much of the devset we look at.
self._devset_size = IntVar(top)
self._devset_size.set(100)
# Set up all the tkinter widgets
self._init_fonts(top)
self._init_widgets(top)
self._init_bindings(top)
self._init_menubar(top)
self.grammarbox.focus()
# If a grammar was given, then display it.
if grammar:
self.grammarbox.insert('end', grammar+'\n')
self.grammarbox.mark_set('insert', '1.0')
# Display the first item in the development set
self.show_devset(0)
self.update()
def _init_bindings(self, top):
top.bind('<Control-n>', self._devset_next)
top.bind('<Control-p>', self._devset_prev)
top.bind('<Control-t>', self.toggle_show_trace)
top.bind('<KeyPress>', self.update)
top.bind('<Control-s>', lambda e: self.save_grammar())
top.bind('<Control-o>', lambda e: self.load_grammar())
self.grammarbox.bind('<Control-t>', self.toggle_show_trace)
self.grammarbox.bind('<Control-n>', self._devset_next)
self.grammarbox.bind('<Control-p>', self._devset_prev)
# Redraw the eval graph when the window size changes
self.evalbox.bind('<Configure>', self._eval_plot)
def _init_fonts(self, top):
# TWhat's our font size (default=same as sysfont)
self._size = IntVar(top)
self._size.set(20)
self._font = tkinter.font.Font(family='helvetica',
size=-self._size.get())
self._smallfont = tkinter.font.Font(family='helvetica',
size=-(int(self._size.get()*14/20)))
def _init_menubar(self, parent):
menubar = Menu(parent)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label='Reset Application', underline=0,
command=self.reset)
filemenu.add_command(label='Save Current Grammar', underline=0,
accelerator='Ctrl-s',
command=self.save_grammar)
filemenu.add_command(label='Load Grammar', underline=0,
accelerator='Ctrl-o',
command=self.load_grammar)
filemenu.add_command(label='Save Grammar History', underline=13,
command=self.save_history)
filemenu.add_command(label='Exit', underline=1,
command=self.destroy, accelerator='Ctrl-q')
menubar.add_cascade(label='File', underline=0, menu=filemenu)
viewmenu = Menu(menubar, tearoff=0)
viewmenu.add_radiobutton(label='Tiny', variable=self._size,
underline=0, value=10, command=self.resize)
viewmenu.add_radiobutton(label='Small', variable=self._size,
underline=0, value=16, command=self.resize)
viewmenu.add_radiobutton(label='Medium', variable=self._size,
underline=0, value=20, command=self.resize)
viewmenu.add_radiobutton(label='Large', variable=self._size,
underline=0, value=24, command=self.resize)
viewmenu.add_radiobutton(label='Huge', variable=self._size,
underline=0, value=34, command=self.resize)
menubar.add_cascade(label='View', underline=0, menu=viewmenu)
devsetmenu = Menu(menubar, tearoff=0)
devsetmenu.add_radiobutton(label='50 sentences',
variable=self._devset_size,
value=50, command=self.set_devset_size)
devsetmenu.add_radiobutton(label='100 sentences',
variable=self._devset_size,
value=100, command=self.set_devset_size)
devsetmenu.add_radiobutton(label='200 sentences',
variable=self._devset_size,
value=200, command=self.set_devset_size)
devsetmenu.add_radiobutton(label='500 sentences',
variable=self._devset_size,
value=500, command=self.set_devset_size)
menubar.add_cascade(label='Development-Set', underline=0,
menu=devsetmenu)
helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label='About', underline=0,
command=self.about)
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
parent.config(menu=menubar)
def toggle_show_trace(self, *e):
if self._showing_trace:
self.show_devset()
else:
self.show_trace()
return 'break'
_SCALE_N = 5 # center on the last 5 examples.
_DRAW_LINES = False
def _eval_plot(self, *e, **config):
width = config.get('width', self.evalbox.winfo_width())
height = config.get('height', self.evalbox.winfo_height())
# Clear the canvas
self.evalbox.delete('all')
# Draw the precision & recall labels.
tag = self.evalbox.create_text(10, height/2-10, justify='left',
anchor='w', text='Precision')
left, right = self.evalbox.bbox(tag)[2] + 5, width-10
tag = self.evalbox.create_text(left + (width-left)/2, height-10,
anchor='s', text='Recall', justify='center')
top, bot = 10, self.evalbox.bbox(tag)[1]-10
# Draw masks for clipping the plot.
bg = self._EVALBOX_PARAMS['background']
self.evalbox.lower(self.evalbox.create_rectangle(0, 0, left-1, 5000,
fill=bg, outline=bg))
self.evalbox.lower(self.evalbox.create_rectangle(0, bot+1, 5000, 5000,
fill=bg, outline=bg))
# Calculate the plot's scale.
if self._autoscale.get() and len(self._history) > 1:
max_precision = max_recall = 0
min_precision = min_recall = 1
for i in range(1, min(len(self._history), self._SCALE_N+1)):
grammar, precision, recall, fmeasure = self._history[-i]
min_precision = min(precision, min_precision)
min_recall = min(recall, min_recall)
max_precision = max(precision, max_precision)
max_recall = max(recall, max_recall)
# if max_precision-min_precision > max_recall-min_recall:
# min_recall -= (max_precision-min_precision)/2
# max_recall += (max_precision-min_precision)/2
# else:
# min_precision -= (max_recall-min_recall)/2
# max_precision += (max_recall-min_recall)/2
# if min_recall < 0:
# max_recall -= min_recall
# min_recall = 0
# if min_precision < 0:
# max_precision -= min_precision
# min_precision = 0
min_precision = max(min_precision-.01, 0)
min_recall = max(min_recall-.01, 0)
max_precision = min(max_precision+.01, 1)
max_recall = min(max_recall+.01, 1)
else:
min_precision = min_recall = 0
max_precision = max_recall = 1
# Draw the axis lines & grid lines
for i in range(11):
x = left + (right-left)*((i/10.-min_recall)/
(max_recall-min_recall))
y = bot - (bot-top)*((i/10.-min_precision)/
(max_precision-min_precision))
if left < x < right:
self.evalbox.create_line(x, top, x, bot, fill='#888')
if top < y < bot:
self.evalbox.create_line(left, y, right, y, fill='#888')
self.evalbox.create_line(left, top, left, bot)
self.evalbox.create_line(left, bot, right, bot)
# Display the plot's scale
self.evalbox.create_text(
left-3, bot, justify='right', anchor='se',
text='%d%%' % (100*min_precision))
self.evalbox.create_text(
left-3, top, justify='right', anchor='ne',
text='%d%%' % (100*max_precision))
self.evalbox.create_text(
left, bot+3, justify='center', anchor='nw',
text='%d%%' % (100*min_recall))
self.evalbox.create_text(
right, bot+3, justify='center', anchor='ne',
text='%d%%' % (100*max_recall))
# Display the scores.
prev_x = prev_y = None
for i, (_, precision, recall, fscore) in enumerate(self._history):
x = left + (right-left) * ((recall-min_recall) /
(max_recall-min_recall))
y = bot - (bot-top) * ((precision-min_precision) /
(max_precision-min_precision))
if i == self._history_index:
self.evalbox.create_oval(x-2,y-2,x+2,y+2,
fill='#0f0', outline='#000')
self.status['text'] = (
'Precision: %.2f%%\t' % (precision*100)+
'Recall: %.2f%%\t' % (recall*100)+
'F-score: %.2f%%' % (fscore*100))
else:
self.evalbox.lower(
self.evalbox.create_oval(x-2,y-2,x+2,y+2,
fill='#afa', outline='#8c8'))
if prev_x is not None and self._eval_lines.get():
self.evalbox.lower(
self.evalbox.create_line(prev_x, prev_y, x, y,
fill='#8c8'))
prev_x, prev_y = x, y
_eval_demon_running = False
def _eval_demon(self):
if self.top is None: return
if self.chunker is None:
self._eval_demon_running = False
return
# Note our starting time.
t0 = time.time()
# If are still typing, then wait for them to finish.
if (time.time()-self._last_keypress < self._EVAL_DELAY and
self.normalized_grammar != self._eval_normalized_grammar):
self._eval_demon_running = True
return self.top.after(int(self._EVAL_FREQ*1000), self._eval_demon)
# If the grammar changed, restart the evaluation.
if self.normalized_grammar != self._eval_normalized_grammar:
# Check if we've seen this grammar already. If so, then
# just use the old evaluation values.
for (g, p, r, f) in self._history:
if self.normalized_grammar == self.normalize_grammar(g):
self._history.append( (g, p, r, f) )
self._history_index = len(self._history) - 1
self._eval_plot()
self._eval_demon_running = False
self._eval_normalized_grammar = None
return
self._eval_index = 0
self._eval_score = ChunkScore(chunk_label=self._chunk_label)
self._eval_grammar = self.grammar
self._eval_normalized_grammar = self.normalized_grammar
# If the grammar is empty, the don't bother evaluating it, or
# recording it in history -- the score will just be 0.
if self.normalized_grammar.strip() == '':
#self._eval_index = self._devset_size.get()
self._eval_demon_running = False
return
# Score the next set of examples
for gold in self.devset[self._eval_index:
min(self._eval_index+self._EVAL_CHUNK,
self._devset_size.get())]:
guess = self._chunkparse(gold.leaves())
self._eval_score.score(gold, guess)
# update our index in the devset.
self._eval_index += self._EVAL_CHUNK
# Check if we're done
if self._eval_index >= self._devset_size.get():
self._history.append( (self._eval_grammar,
self._eval_score.precision(),
self._eval_score.recall(),
self._eval_score.f_measure()) )
self._history_index = len(self._history)-1
self._eval_plot()
self._eval_demon_running = False
self._eval_normalized_grammar = None
else:
progress = 100*self._eval_index/self._devset_size.get()
self.status['text'] = ('Evaluating on Development Set (%d%%)' %
progress)
self._eval_demon_running = True
self._adaptively_modify_eval_chunk(time.time() - t0)
self.top.after(int(self._EVAL_FREQ*1000), self._eval_demon)
def _adaptively_modify_eval_chunk(self, t):
"""
Modify _EVAL_CHUNK to try to keep the amount of time that the
eval demon takes between _EVAL_DEMON_MIN and _EVAL_DEMON_MAX.
:param t: The amount of time that the eval demon took.
"""
if t > self._EVAL_DEMON_MAX and self._EVAL_CHUNK > 5:
self._EVAL_CHUNK = min(self._EVAL_CHUNK-1,
max(int(self._EVAL_CHUNK*(self._EVAL_DEMON_MAX/t)),
self._EVAL_CHUNK-10))
elif t < self._EVAL_DEMON_MIN:
self._EVAL_CHUNK = max(self._EVAL_CHUNK+1,
min(int(self._EVAL_CHUNK*(self._EVAL_DEMON_MIN/t)),
self._EVAL_CHUNK+10))
def _init_widgets(self, top):
frame0 = Frame(top, **self._FRAME_PARAMS)
frame0.grid_columnconfigure(0, weight=4)
frame0.grid_columnconfigure(3, weight=2)
frame0.grid_rowconfigure(1, weight=1)
frame0.grid_rowconfigure(5, weight=1)
# The grammar
self.grammarbox = Text(frame0, font=self._font,
**self._GRAMMARBOX_PARAMS)
self.grammarlabel = Label(frame0, font=self._font, text='Grammar:',
highlightcolor='black',
background=self._GRAMMARBOX_PARAMS['background'])
self.grammarlabel.grid(column=0, row=0, sticky='SW')
self.grammarbox.grid(column=0, row=1, sticky='NEWS')
# Scroll bar for grammar
grammar_scrollbar = Scrollbar(frame0, command=self.grammarbox.yview)
grammar_scrollbar.grid(column=1, row=1, sticky='NWS')
self.grammarbox.config(yscrollcommand=grammar_scrollbar.set)
# grammar buttons
bg = self._FRAME_PARAMS['background']
frame3 = Frame(frame0, background=bg)
frame3.grid(column=0, row=2, sticky='EW')
Button(frame3, text='Prev Grammar', command=self._history_prev,
**self._BUTTON_PARAMS).pack(side='left')
Button(frame3, text='Next Grammar', command=self._history_next,
**self._BUTTON_PARAMS).pack(side='left')
# Help box
self.helpbox = Text(frame0, font=self._smallfont,
**self._HELPBOX_PARAMS)
self.helpbox.grid(column=3, row=1, sticky='NEWS')
self.helptabs = {}
bg = self._FRAME_PARAMS['background']
helptab_frame = Frame(frame0, background=bg)
helptab_frame.grid(column=3, row=0, sticky='SW')
for i, (tab, tabstops, text) in enumerate(self.HELP):
label = Label(helptab_frame, text=tab, font=self._smallfont)
label.grid(column=i*2, row=0, sticky='S')
#help_frame.grid_columnconfigure(i, weight=1)
#label.pack(side='left')
label.bind('<ButtonPress>', lambda e, tab=tab: self.show_help(tab))
self.helptabs[tab] = label
Frame(helptab_frame, height=1, width=self._HELPTAB_SPACER,
background=bg).grid(column=i*2+1, row=0)
self.helptabs[self.HELP[0][0]].configure(font=self._font)
self.helpbox.tag_config('elide', elide=True)
for (tag, params) in self.HELP_AUTOTAG:
self.helpbox.tag_config('tag-%s' % tag, **params)
self.show_help(self.HELP[0][0])
# Scroll bar for helpbox
help_scrollbar = Scrollbar(frame0, command=self.helpbox.yview)
self.helpbox.config(yscrollcommand=help_scrollbar.set)
help_scrollbar.grid(column=4, row=1, sticky='NWS')
# The dev set
frame4 = Frame(frame0, background=self._FRAME_PARAMS['background'])
self.devsetbox = Text(frame4, font=self._font,
**self._DEVSETBOX_PARAMS)
self.devsetbox.pack(expand=True, fill='both')
self.devsetlabel = Label(frame0, font=self._font,
text='Development Set:', justify='right',
background=self._DEVSETBOX_PARAMS['background'])
self.devsetlabel.grid(column=0, row=4, sticky='SW')
frame4.grid(column=0, row=5, sticky='NEWS')
# dev set scrollbars
self.devset_scroll = Scrollbar(frame0, command=self._devset_scroll)
self.devset_scroll.grid(column=1, row=5, sticky='NWS')
self.devset_xscroll = Scrollbar(frame4, command=self.devsetbox.xview,
orient='horiz')
self.devsetbox['xscrollcommand'] = self.devset_xscroll.set
self.devset_xscroll.pack(side='bottom', fill='x')
# dev set buttons
bg = self._FRAME_PARAMS['background']
frame1 = Frame(frame0, background=bg)
frame1.grid(column=0, row=7, sticky='EW')
Button(frame1, text='Prev Example (Ctrl-p)',
command=self._devset_prev,
**self._BUTTON_PARAMS).pack(side='left')
Button(frame1, text='Next Example (Ctrl-n)',
command=self._devset_next,
**self._BUTTON_PARAMS).pack(side='left')
self.devset_button = Button(frame1, text='Show example',
command=self.show_devset,
state='disabled',
**self._BUTTON_PARAMS)
self.devset_button.pack(side='right')
self.trace_button = Button(frame1, text='Show trace',
command=self.show_trace,
**self._BUTTON_PARAMS)
self.trace_button.pack(side='right')
# evaluation box
self.evalbox = Canvas(frame0, **self._EVALBOX_PARAMS)
label = Label(frame0, font=self._font, text='Evaluation:',
justify='right', background=self._EVALBOX_PARAMS['background'])
label.grid(column=3, row=4, sticky='SW')
self.evalbox.grid(column=3, row=5, sticky='NEWS', columnspan=2)
# evaluation box buttons
bg = self._FRAME_PARAMS['background']
frame2 = Frame(frame0, background=bg)
frame2.grid(column=3, row=7, sticky='EW')
self._autoscale = IntVar(self.top)
self._autoscale.set(False)
Checkbutton(frame2, variable=self._autoscale, command=self._eval_plot,
text='Zoom', **self._BUTTON_PARAMS).pack(side='left')
self._eval_lines = IntVar(self.top)
self._eval_lines.set(False)
Checkbutton(frame2, variable=self._eval_lines, command=self._eval_plot,
text='Lines', **self._BUTTON_PARAMS).pack(side='left')
Button(frame2, text='History',
**self._BUTTON_PARAMS).pack(side='right')
# The status label
self.status = Label(frame0, font=self._font, **self._STATUS_PARAMS)
self.status.grid(column=0, row=9, sticky='NEW', padx=3, pady=2,
columnspan=5)
# Help box & devset box can't be edited.
self.helpbox['state'] = 'disabled'
self.devsetbox['state'] = 'disabled'
# Spacers
bg = self._FRAME_PARAMS['background']
Frame(frame0, height=10, width=0, background=bg).grid(column=0, row=3)
Frame(frame0, height=0, width=10, background=bg).grid(column=2, row=0)
Frame(frame0, height=6, width=0, background=bg).grid(column=0, row=8)
# pack the frame.
frame0.pack(fill='both', expand=True)
# Set up colors for the devset box
self.devsetbox.tag_config('true-pos', background='#afa',
underline='True')
self.devsetbox.tag_config('false-neg', underline='True',
foreground='#800')
self.devsetbox.tag_config('false-pos', background='#faa')
self.devsetbox.tag_config('trace', foreground='#666', wrap='none')
self.devsetbox.tag_config('wrapindent', lmargin2=30, wrap='none')
self.devsetbox.tag_config('error', foreground='#800')
# And for the grammarbox
self.grammarbox.tag_config('error', background='#fec')
self.grammarbox.tag_config('comment', foreground='#840')
self.grammarbox.tag_config('angle', foreground='#00f')
self.grammarbox.tag_config('brace', foreground='#0a0')
self.grammarbox.tag_config('hangindent', lmargin1=0, lmargin2=40)
_showing_trace = False
def show_trace(self, *e):
self._showing_trace = True
self.trace_button['state'] = 'disabled'
self.devset_button['state'] = 'normal'
self.devsetbox['state'] = 'normal'
#self.devsetbox['wrap'] = 'none'
self.devsetbox.delete('1.0', 'end')
self.devsetlabel['text']='Development Set (%d/%d)' % (
(self.devset_index+1, self._devset_size.get()))
if self.chunker is None:
self.devsetbox.insert('1.0', 'Trace: waiting for a valid grammar.')
self.devsetbox.tag_add('error', '1.0', 'end')
return # can't do anything more
gold_tree = self.devset[self.devset_index]
rules = self.chunker.rules()
# Calculate the tag sequence
tagseq = '\t'
charnum = [1]
for wordnum, (word, pos) in enumerate(gold_tree.leaves()):
tagseq += '%s ' % pos
charnum.append(len(tagseq))
self.charnum = dict(((i, j), charnum[j])
for i in range(len(rules)+1)
for j in range(len(charnum)))
self.linenum = dict((i,i*2+2) for i in range(len(rules)+1))
for i in range(len(rules)+1):
if i == 0:
self.devsetbox.insert('end', 'Start:\n')
self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
else:
self.devsetbox.insert('end', 'Apply %s:\n' % rules[i-1])
self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
# Display the tag sequence.
self.devsetbox.insert('end', tagseq+'\n')
self.devsetbox.tag_add('wrapindent','end -2c linestart','end -2c')
# Run a partial parser, and extract gold & test chunks
chunker = RegexpChunkParser(rules[:i])
test_tree = self._chunkparse(gold_tree.leaves())
gold_chunks = self._chunks(gold_tree)
test_chunks = self._chunks(test_tree)
# Compare them.
for chunk in gold_chunks.intersection(test_chunks):
self._color_chunk(i, chunk, 'true-pos')
for chunk in gold_chunks - test_chunks:
self._color_chunk(i, chunk, 'false-neg')
for chunk in test_chunks - gold_chunks:
self._color_chunk(i, chunk, 'false-pos')
self.devsetbox.insert('end', 'Finished.\n')
self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
# This is a hack, because the x-scrollbar isn't updating its
# position right -- I'm not sure what the underlying cause is
# though. (This is on OS X w/ python 2.5)
self.top.after(100, self.devset_xscroll.set, 0, .3)
def show_help(self, tab):
self.helpbox['state'] = 'normal'
self.helpbox.delete('1.0', 'end')
for (name, tabstops, text) in self.HELP:
if name == tab:
text = text.replace('<<TAGSET>>', '\n'.join(
('\t%s\t%s' % item for item in sorted(list(self.tagset.items()),
key=lambda t_w:re.match('\w+',t_w[0]) and (0,t_w[0]) or (1,t_w[0])))))
self.helptabs[name].config(**self._HELPTAB_FG_PARAMS)
self.helpbox.config(tabs=tabstops)
self.helpbox.insert('1.0', text+'\n'*20)
C = '1.0 + %d chars'
for (tag, params) in self.HELP_AUTOTAG:
pattern = '(?s)(<%s>)(.*?)(</%s>)' % (tag, tag)
for m in re.finditer(pattern, text):
self.helpbox.tag_add('elide',
C % m.start(1), C % m.end(1))
self.helpbox.tag_add('tag-%s' % tag,
C % m.start(2), C % m.end(2))
self.helpbox.tag_add('elide',
C % m.start(3), C % m.end(3))
else:
self.helptabs[name].config(**self._HELPTAB_BG_PARAMS)
self.helpbox['state'] = 'disabled'
def _history_prev(self, *e):
self._view_history(self._history_index-1)
return 'break'
def _history_next(self, *e):
self._view_history(self._history_index+1)
return 'break'
def _view_history(self, index):
# Bounds & sanity checking:
index = max(0, min(len(self._history)-1, index))
if not self._history: return
# Already viewing the requested history item?
if index == self._history_index:
return
# Show the requested grammar. It will get added to _history
# only if they edit it (causing self.update() to get run.)
self.grammarbox['state'] = 'normal'
self.grammarbox.delete('1.0', 'end')
self.grammarbox.insert('end', self._history[index][0])
self.grammarbox.mark_set('insert', '1.0')
self._history_index = index
self._syntax_highlight_grammar(self._history[index][0])
# Record the normalized grammar & regenerate the chunker.
self.normalized_grammar = self.normalize_grammar(
self._history[index][0])
if self.normalized_grammar:
rules = [RegexpChunkRule.parse(line)
for line in self.normalized_grammar.split('\n')]
else:
rules = []
self.chunker = RegexpChunkParser(rules)
# Show the score.
self._eval_plot()
# Update the devset box
self._highlight_devset()
if self._showing_trace: self.show_trace()
# Update the grammar label
if self._history_index < len(self._history)-1:
self.grammarlabel['text'] = 'Grammar %s/%s:' % (
self._history_index+1, len(self._history))
else:
self.grammarlabel['text'] = 'Grammar:'
def _devset_next(self, *e):
self._devset_scroll('scroll', 1, 'page')
return 'break'
def _devset_prev(self, *e):
self._devset_scroll('scroll', -1, 'page')
return 'break'
def destroy(self, *e):
if self.top is None: return
self.top.destroy()
self.top = None
def _devset_scroll(self, command, *args):
N = 1 # size of a page -- one sentence.
showing_trace = self._showing_trace
if command == 'scroll' and args[1].startswith('unit'):
self.show_devset(self.devset_index+int(args[0]))
elif command == 'scroll' and args[1].startswith('page'):
self.show_devset(self.devset_index+N*int(args[0]))
elif command == 'moveto':
self.show_devset(int(float(args[0])*self._devset_size.get()))
else:
assert 0, 'bad scroll command %s %s' % (command, args)
if showing_trace:
self.show_trace()
def show_devset(self, index=None):
if index is None: index = self.devset_index
# Bounds checking
index = min(max(0, index), self._devset_size.get()-1)
if index == self.devset_index and not self._showing_trace: return
self.devset_index = index
self._showing_trace = False
self.trace_button['state'] = 'normal'
self.devset_button['state'] = 'disabled'
# Clear the text box.
self.devsetbox['state'] = 'normal'
self.devsetbox['wrap'] = 'word'
self.devsetbox.delete('1.0', 'end')
self.devsetlabel['text']='Development Set (%d/%d)' % (
(self.devset_index+1, self._devset_size.get()))
# Add the sentences
sample = self.devset[self.devset_index:self.devset_index+1]
self.charnum = {}
self.linenum = {0:1}
for sentnum, sent in enumerate(sample):
linestr = ''
for wordnum, (word, pos) in enumerate(sent.leaves()):
self.charnum[sentnum, wordnum] = len(linestr)
linestr += '%s/%s ' % (word, pos)
self.charnum[sentnum, wordnum+1] = len(linestr)
self.devsetbox.insert('end', linestr[:-1]+'\n\n')
# Highlight chunks in the dev set
if self.chunker is not None:
self._highlight_devset()
self.devsetbox['state'] = 'disabled'
# Update the scrollbar
first = float(self.devset_index)/self._devset_size.get()
last = float(self.devset_index+2)/self._devset_size.get()
self.devset_scroll.set(first, last)
def _chunks(self, tree):
chunks = set()
wordnum = 0
for child in tree:
if isinstance(child, Tree):
if child.label() == self._chunk_label:
chunks.add( (wordnum, wordnum+len(child)) )
wordnum += len(child)
else:
wordnum += 1
return chunks
def _syntax_highlight_grammar(self, grammar):
if self.top is None: return
self.grammarbox.tag_remove('comment', '1.0', 'end')
self.grammarbox.tag_remove('angle', '1.0', 'end')
self.grammarbox.tag_remove('brace', '1.0', 'end')
self.grammarbox.tag_add('hangindent', '1.0', 'end')
for lineno, line in enumerate(grammar.split('\n')):
if not line.strip(): continue
m = re.match(r'(\\.|[^#])*(#.*)?', line)
comment_start = None
if m.group(2):
comment_start = m.start(2)
s = '%d.%d' % (lineno+1, m.start(2))
e = '%d.%d' % (lineno+1, m.end(2))
self.grammarbox.tag_add('comment', s, e)
for m in re.finditer('[<>{}]', line):
if comment_start is not None and m.start() >= comment_start:
break
s = '%d.%d' % (lineno+1, m.start())
e = '%d.%d' % (lineno+1, m.end())
if m.group() in '<>':
self.grammarbox.tag_add('angle', s, e)
else:
self.grammarbox.tag_add('brace', s, e)
def _grammarcheck(self, grammar):
if self.top is None: return
self.grammarbox.tag_remove('error', '1.0', 'end')
self._grammarcheck_errs = []
for lineno, line in enumerate(grammar.split('\n')):
line = re.sub(r'((\\.|[^#])*)(#.*)?', r'\1', line)
line = line.strip()
if line:
try:
RegexpChunkRule.parse(line)
except ValueError as e:
self.grammarbox.tag_add('error', '%s.0' % (lineno+1),
'%s.0 lineend' % (lineno+1))
self.status['text'] = ''
def update(self, *event):
# Record when update was called (for grammarcheck)
if event:
self._last_keypress = time.time()
# Read the grammar from the Text box.
self.grammar = grammar = self.grammarbox.get('1.0', 'end')
# If the grammar hasn't changed, do nothing:
normalized_grammar = self.normalize_grammar(grammar)
if normalized_grammar == self.normalized_grammar:
return
else:
self.normalized_grammar = normalized_grammar
# If the grammar has changed, and we're looking at history,
# then stop looking at history.
if self._history_index < len(self._history)-1:
self.grammarlabel['text'] = 'Grammar:'
self._syntax_highlight_grammar(grammar)
# The grammar has changed; try parsing it. If it doesn't
# parse, do nothing. (flag error location?)
try:
# Note: the normalized grammar has no blank lines.
if normalized_grammar:
rules = [RegexpChunkRule.parse(line)
for line in normalized_grammar.split('\n')]
else:
rules = []
except ValueError as e:
# Use the un-normalized grammar for error highlighting.
self._grammarcheck(grammar)
self.chunker = None
return
self.chunker = RegexpChunkParser(rules)
self.grammarbox.tag_remove('error', '1.0', 'end')
self.grammar_changed = time.time()
# Display the results
if self._showing_trace:
self.show_trace()
else:
self._highlight_devset()
# Start the eval demon
if not self._eval_demon_running:
self._eval_demon()
def _highlight_devset(self, sample=None):
if sample is None:
sample = self.devset[self.devset_index:self.devset_index+1]
self.devsetbox.tag_remove('true-pos', '1.0', 'end')
self.devsetbox.tag_remove('false-neg', '1.0', 'end')
self.devsetbox.tag_remove('false-pos', '1.0', 'end')
# Run the grammar on the test cases.
for sentnum, gold_tree in enumerate(sample):
# Run the chunk parser
test_tree = self._chunkparse(gold_tree.leaves())
# Extract gold & test chunks
gold_chunks = self._chunks(gold_tree)
test_chunks = self._chunks(test_tree)
# Compare them.
for chunk in gold_chunks.intersection(test_chunks):
self._color_chunk(sentnum, chunk, 'true-pos')
for chunk in gold_chunks - test_chunks:
self._color_chunk(sentnum, chunk, 'false-neg')
for chunk in test_chunks - gold_chunks:
self._color_chunk(sentnum, chunk, 'false-pos')
def _chunkparse(self, words):
try:
return self.chunker.parse(words)
except (ValueError, IndexError) as e:
# There's an error somewhere in the grammar, but we're not sure
# exactly where, so just mark the whole grammar as bad.
# E.g., this is caused by: "({<NN>})"
self.grammarbox.tag_add('error', '1.0', 'end')
# Treat it as tagging nothing:
return words
def _color_chunk(self, sentnum, chunk, tag):
start, end = chunk
self.devsetbox.tag_add(tag,
'%s.%s' % (self.linenum[sentnum], self.charnum[sentnum, start]),
'%s.%s' % (self.linenum[sentnum], self.charnum[sentnum, end]-1))
def reset(self):
# Clear various variables
self.chunker = None
self.grammar = None
self.normalized_grammar = None
self.grammar_changed = 0
self._history = []
self._history_index = 0
# Update the on-screen display.
self.grammarbox.delete('1.0', 'end')
self.show_devset(0)
self.update()
#self._eval_plot()
SAVE_GRAMMAR_TEMPLATE = (
'# Regexp Chunk Parsing Grammar\n'
'# Saved %(date)s\n'
'#\n'
'# Development set: %(devset)s\n'
'# Precision: %(precision)s\n'
'# Recall: %(recall)s\n'
'# F-score: %(fscore)s\n\n'
'%(grammar)s\n')
def save_grammar(self, filename=None):
if not filename:
ftypes = [('Chunk Gramamr', '.chunk'),
('All files', '*')]
filename = tkinter.filedialog.asksaveasfilename(filetypes=ftypes,
defaultextension='.chunk')
if not filename: return
if (self._history and self.normalized_grammar ==
self.normalize_grammar(self._history[-1][0])):
precision, recall, fscore = ['%.2f%%' % (100*v) for v in
self._history[-1][1:]]
elif self.chunker is None:
precision = recall = fscore = 'Grammar not well formed'
else:
precision = recall = fscore = 'Not finished evaluation yet'
with open(filename, 'w') as outfile:
outfile.write(self.SAVE_GRAMMAR_TEMPLATE % dict(
date=time.ctime(), devset=self.devset_name,
precision=precision, recall=recall, fscore=fscore,
grammar=self.grammar.strip()))
def load_grammar(self, filename=None):
if not filename:
ftypes = [('Chunk Gramamr', '.chunk'),
('All files', '*')]
filename = tkinter.filedialog.askopenfilename(filetypes=ftypes,
defaultextension='.chunk')
if not filename: return
self.grammarbox.delete('1.0', 'end')
self.update()
with open(filename, 'r') as infile:
grammar = infile.read()
grammar = re.sub('^\# Regexp Chunk Parsing Grammar[\s\S]*'
'F-score:.*\n', '', grammar).lstrip()
self.grammarbox.insert('1.0', grammar)
self.update()
def save_history(self, filename=None):
if not filename:
ftypes = [('Chunk Gramamr History', '.txt'),
('All files', '*')]
filename = tkinter.filedialog.asksaveasfilename(filetypes=ftypes,
defaultextension='.txt')
if not filename: return
with open(filename, 'w') as outfile:
outfile.write('# Regexp Chunk Parsing Grammar History\n')
outfile.write('# Saved %s\n' % time.ctime())
outfile.write('# Development set: %s\n' % self.devset_name)
for i, (g, p, r, f) in enumerate(self._history):
hdr = ('Grammar %d/%d (precision=%.2f%%, recall=%.2f%%, '
'fscore=%.2f%%)' % (i+1, len(self._history),
p*100, r*100, f*100))
outfile.write('\n%s\n' % hdr)
outfile.write(''.join(' %s\n' % line for line in g.strip().split()))
if not (self._history and self.normalized_grammar ==
self.normalize_grammar(self._history[-1][0])):
if self.chunker is None:
outfile.write('\nCurrent Grammar (not well-formed)\n')
else:
outfile.write('\nCurrent Grammar (not evaluated)\n')
outfile.write(''.join(' %s\n' % line for line
in self.grammar.strip().split()))
def about(self, *e):
ABOUT = ("NLTK RegExp Chunk Parser Application\n"+
"Written by Edward Loper")
TITLE = 'About: Regular Expression Chunk Parser Application'
try:
from tkinter.messagebox import Message
Message(message=ABOUT, title=TITLE).show()
except:
ShowText(self.top, TITLE, ABOUT)
def set_devset_size(self, size=None):
if size is not None: self._devset_size.set(size)
self._devset_size.set(min(len(self.devset), self._devset_size.get()))
self.show_devset(1)
self.show_devset(0)
# what about history? Evaluated at diff dev set sizes!
def resize(self, size=None):
if size is not None: self._size.set(size)
size = self._size.get()
self._font.configure(size=-(abs(size)))
self._smallfont.configure(size=min(-10, -(abs(size))*14/20))
def mainloop(self, *args, **kwargs):
"""
Enter the Tkinter mainloop. This function must be called if
this demo is created from a non-interactive program (e.g.
from a secript); otherwise, the demo will close as soon as
the script completes.
"""
if in_idle(): return
self.top.mainloop(*args, **kwargs)
[docs]def app():
RegexpChunkApp().mainloop()
if __name__ == '__main__':
app()
__all__ = ['app']