Coverage for nltk.app.chunkparser_app : 12%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
# Natural Language Toolkit: Regexp Chunk Parser Application # # Copyright (C) 2001-2012 NLTK Project # Author: Edward Loper <edloper@gradient.cis.upenn.edu> # URL: <http://www.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.
Frame, IntVar, Label, Menu, Scrollbar, Text, Tk)
""" 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.) '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', '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') ]
('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 ##/////////////////////////////////////////////////////////////////
"""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."""
"""The number of sentences that should be evaluated by the eval demon each time it runs.""" """The frequency (in seconds) at which the eval demon is run""" """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.""" """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."""
width=40, height=12, background='#efe', highlightbackground='#efe', highlightthickness=1, relief='groove', border=2, wrap='word') width=15, height=15, background='#efe', highlightbackground='#efe', foreground='#555', highlightthickness=1, relief='groove', border=2, wrap='word') width=70, height=10, background='#eef', highlightbackground='#eef', highlightthickness=1, relief='groove', border=2, wrap='word', tabs=(30,)) background='#9bb', relief='groove', border=2) family='helvetica', size=-20) background='#777', padx=2, pady=2, border=3) background='#eef', highlightbackground='#eef', highlightthickness=1, relief='groove', border=2, width=300, height=280) background='#777', activebackground='#777', highlightbackground='#777')
# 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
grammar = '', chunk_node='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_node = chunk_node
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_node=chunk_node) """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()
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)
# TWhat's our font size (default=same as sysfont) self._size = IntVar(top) self._size.set(20) self._font = tkFont.Font(family='helvetica', size=-self._size.get()) self._smallfont = tkFont.Font(family='helvetica', size=-(self._size.get()*14/20))
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)
if self._showing_trace: self.show_devset() else: self.show_trace() return 'break'
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
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_node=self._chunk_node) 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)
""" 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))
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)
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)
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(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'
self._view_history(self._history_index-1) return 'break'
self._view_history(self._history_index+1) return 'break'
# 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:'
self._devset_scroll('scroll', 1, 'page') return 'break'
self._devset_scroll('scroll', -1, 'page') return 'break'
if self.top is None: return self.top.destroy() self.top = None
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()
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)
chunks = set() wordnum = 0 for child in tree: if isinstance(child, Tree): if child.node == self._chunk_node: chunks.add( (wordnum, wordnum+len(child)) ) wordnum += len(child) else: wordnum += 1 return chunks
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)
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'] = ''
# 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()
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')
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
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))
# 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()
'# 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')
if not filename: ftypes = [('Chunk Gramamr', '.chunk'), ('All files', '*')] filename = tkFileDialog.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'
out = open(filename, 'w') out.write(self.SAVE_GRAMMAR_TEMPLATE % dict( date=time.ctime(), devset=self.devset_name, precision=precision, recall=recall, fscore=fscore, grammar=self.grammar.strip())) out.close()
if not filename: ftypes = [('Chunk Gramamr', '.chunk'), ('All files', '*')] filename = tkFileDialog.askopenfilename(filetypes=ftypes, defaultextension='.chunk') if not filename: return self.grammarbox.delete('1.0', 'end') self.update() grammar = open(filename).read() grammar = re.sub('^\# Regexp Chunk Parsing Grammar[\s\S]*' 'F-score:.*\n', '', grammar).lstrip() self.grammarbox.insert('1.0', grammar) self.update()
if not filename: ftypes = [('Chunk Gramamr History', '.txt'), ('All files', '*')] filename = tkFileDialog.asksaveasfilename(filetypes=ftypes, defaultextension='.txt') if not filename: return
out = open(filename, 'w') out.write('# Regexp Chunk Parsing Grammar History\n') out.write('# Saved %s\n' % time.ctime()) out.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)) out.write('\n%s\n' % hdr) out.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: out.write('\nCurrent Grammar (not well-formed)\n') else: out.write('\nCurrent Grammar (not evaluated)\n') out.write(''.join(' %s\n' % line for line in self.grammar.strip().split())) out.close()
ABOUT = ("NLTK RegExp Chunk Parser Application\n"+ "Written by Edward Loper") TITLE = 'About: Regular Expression Chunk Parser Application' try: from tkMessageBox import Message Message(message=ABOUT, title=TITLE).show() except: ShowText(self.top, TITLE, ABOUT)
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!
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))
""" 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)
RegexpChunkApp().mainloop()
app()
|