s439508/PCQRSCANER
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
74de674d28
PCQRSCANER/venv/Lib/site-packages/nltk/app/chunkparser_app.py

1505 lines
56 KiB
Python
Raw Normal View History

3
2019-12-22 21:51:47 +01:00
# Natural Language Toolkit: Regexp Chunk Parser Application
#
# Copyright (C) 2001-2019 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.
from __future__ import division
import time
import textwrap
import re
import random
from six.moves.tkinter import (
Button,
Canvas,
Checkbutton,
Frame,
IntVar,
Label,
Menu,
Scrollbar,
Text,
Tk,
)
from six.moves.tkinter_tkfiledialog import askopenfilename, asksaveasfilename
from six.moves.tkinter_font import Font
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>>'
+ '</hangindent>\n', # this gets auto-substituted w/ self.TAGSET
),
]
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 = 0.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 = 0.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 = Font(family='helvetica', size=-self._size.get())
self._smallfont = 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 - 0.01, 0)
min_recall = max(min_recall - 0.01, 0)
max_precision = min(max_precision + 0.01, 1)
max_recall = min(max_recall + 0.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.0 - min_recall) / (max_recall - min_recall)
)
y = bot - (bot - top) * (
(i / 10.0 - 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, 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.fromstring(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 = self.devset_index / self._devset_size.get()
last = (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.fromstring(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.fromstring(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 = 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 = 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 = 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 six.moves.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)
def app():
RegexpChunkApp().mainloop()
if __name__ == '__main__':
app()
__all__ = ['app']
Reference in New Issue Copy Permalink