4Ic@sdZddkZddkZddkZddkZddklZddklZddk Tde ei fdYZ dei fd YZ d e fd YZd efd YZdefdYZdefdYZdefdYZdefdYZdefdYZdefdYZddZddddd ed!dd"Zed#jo endS($s- Brill's transformational rule-based tagger. iN(t defaultdict(tuntag(t*t BrillTaggercBs/eZdZdZdZdZdZRS(sq Brill's transformational rule-based tagger. Brill taggers use an X{initial tagger} (such as L{tag.DefaultTagger}) to assign an intial tag sequence to a text; and then apply an ordered list of transformational rules to correct the tags of individual tokens. These transformation rules are specified by the L{BrillRule} interface. Brill taggers can be created directly, from an initial tagger and a list of transformational rules; but more often, Brill taggers are created by learning rules from a training corpus, using either L{BrillTaggerTrainer} or L{FastBrillTaggerTrainer}. s!nltk.BrillTaggercCs||_t||_dS(s @param initial_tagger: The initial tagger @type initial_tagger: L{TaggerI} @param rules: An ordered list of transformation rules that should be used to correct the initial tagging. @type rules: C{list} of L{BrillRule} N(t_initial_taggerttuplet_rules(tselftinitial_taggertrules((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyt__init__,s cCs|iS(N(R(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR 7sc Cs|ii|}tt}x1t|D]#\}\}}||i|q+Wxq|iD]f}|i|ig}|i ||} x6| D].}||ii |||i i|qWq\W|S(N( RttagRtsett enumeratetaddRtgett original_tagtapplytremovetreplacement_tag( Rttokenst tagged_tokensttag_to_positionstittokenR trulet positionstchanged((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR :s   (t__name__t __module__t__doc__tyaml_tagR R R (((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs   t BrillRulecBsGeZdZdZedZdZdZdZdZ RS(s* An interface for tag transformations on a tagged corpus, as performed by brill taggers. Each transformation finds all tokens in the corpus that are tagged with a specific X{original tag} and satisfy a specific X{condition}, and replaces their tags with a X{replacement tag}. For any given transformation, the original tag, replacement tag, and condition are fixed. Conditions may depend on the token under consideration, as well as any other tokens in the corpus. Brill rules must be comparable and hashable. cCs0|itjp td||_||_dS(Ns#BrillRule is an abstract base class(t __class__R tAssertionErrorRR(RRR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR fs   cCs|tjott|}ng}|D]$}|i||o ||q.q.~}x)|D]!}||d|if||C{end} for any condition. s-ProximateTokensRule is an abstract base classs!Condition %s has an invalid rangeN(R!R.R"R R t _conditionst ValueError(RRRt conditionststetv((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR s   c CsS|i|itdt|dtd|iDd|id|i}|S(Nt descriptionR1cssx|]}t|VqWdS(N(tlist(t.0tx((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pys storiginalt replacement(trepresent_mappingRtdicttstrR6R/RR(tclstdumpertdatatnode((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pytto_yamls   cCs;|i|dt}||d|dd|dDS(NtdeepR9R:cssx|]}t|VqWdS(N(R(R7R8((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pys sR1(tconstruct_mappingtTrue(R>tloaderRAtmap((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyt from_yamlscCstp tddS(s Returns some property characterizing this token, such as its base lexical item or its tag. Each implentation of this method should correspond to an implementation of the method with the same name in a subclass of L{ProximateTokensTemplate}. @param token: The token @type token: Token @return: The property @rtype: any s2ProximateTokenRules must define extract_property()N(R)R"(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pytextract_propertysc Cs||d|ijotSnx|iD]|\}}}td||}t||dt|}x:t||D]%}|i|||joPqyqyWtSq*WtS(Nii( RR)R/tmaxtminR%R$RIRE( RRR*tstarttendtvalR2R3R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR&s  cCsc||jpV|dj oI|i|ijo6|i|ijo#|i|ijo|i|ijS(N(R#R!RRR/(Rtother((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR+s   cCs ||j S(N((RRO((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR,scCsJy |iSWn8t|i|i|i|iif|_|iSnXdS(N(t_ProximateTokensRule__hashthashRRR/R!R(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR-s  cCsy |iSWnvdig}|iD]#\}}}|d|||fq%~}d|ii|i|i|f|_|iSnXdS(Ns and s %s in %d...%ds<%s: %s->%s if %s>(t_ProximateTokensRule__reprtjoinR/R!RRR(RR'R2R3R4R1((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyt__repr__"s  6cCsxd|i|if}t|idjo d}n;ddig}|iD]}||i|qM~}||S(Ns%s -> %sits if s, and (RRR%R/RSt_condition_to_str(RR:R1R'tc((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyt__str__0s   *cCs/|\}}}d|i|i|||fS(sz Return a string representation of the given condition. This helper method is used by L{__str__}. sthe %s of %s is %r(t PROPERTY_NAMEt _range_to_str(Rt conditionRLRMtvalue((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRV:scCs||jo djnodSn||jo djnodSn||jo djnodSn||jo|djo d| Snk||jo|djo d|SnE|djod |}n|djod |}nd ||fSd S( sx Return a string representation for the given range. This helper method is used by L{__str__}. is this wordisthe preceding wordisthe following words word i-%ds word i+%ds+%dswords i%s...i%sN((RRLRM((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRZCs  (RRRR t classmethodRBRHt staticmethodRIR&R+R,R-RTRXRVRZ(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR.s      tProximateTagsRulecBs)eZdZdZdZedZRS(s A rule which examines the tags of nearby tokens. @see: superclass L{ProximateTokensRule} for details. @see: L{SymmetricProximateTokensTemplate}, which generates these rules. R s!ProximateTagsRulecCs|dS(s@return: The given token's tag.i((R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRI_s(RRRRYRR^RI(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR_WstProximateWordsRulecBs)eZdZdZdZedZRS(s A rule which examines the base types of nearby tokens. @see: L{ProximateTokensRule} for details. @see: L{SymmetricProximateTokensTemplate}, which generates these rules. ttexts!ProximateWordsRulecCs|dS(s @return: The given token's text.i((R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRIls(RRRRYRR^RI(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR`dstBrillTemplateIcBs)eZdZdZdZdZRS(s An interface for generating lists of transformational rules that apply at given sentence positions. C{BrillTemplateI} is used by C{Brill} training algorithms to generate candidate rules. cCs tddS(Ns'BrillTemplateI is an abstract interface(R"(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR {scCs tddS(s/ Return a list of the transformational rules that would correct the C{i}th subtoken's tag in the given token. In particular, return a list of zero or more rules that would change C{tagged_tokens[i][1]} to C{correctTag}, if applied to C{token}. If the C{i}th subtoken already has the correct tag (i.e., if C{tagged_tokens[i][1]} == C{correctTag}), then C{applicable_rules} should return the empty list. @param tokens: The tagged tokens being tagged. @type tokens: C{list} of C{tuple} @param i: The index of the token whose tag should be corrected. @type i: C{int} @param correctTag: The correct tag for the C{i}th token. @type correctTag: (any) @rtype: C{list} of L{BrillRule} s'BrillTemplateI is an abstract interfaceN(R"(RRRt correctTag((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pytapplicable_rules~scCs tddS(s Returns the set of indices C{i} such that C{applicable_rules(token, i, ...)} depends on the value of the C{index}th subtoken of C{token}. This method is used by the "fast" Brill tagger trainer. @param token: The tokens being tagged. @type token: C{list} of C{tuple} @param index: The index whose neighborhood should be returned. @type index: C{int} @rtype: C{Set} s'BrillTemplateI is an abstract interfaceN(R"(RRR*((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pytget_neighborhoods(RRRR RdRe(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRbus  tProximateTokensTemplatecBs2eZdZdZdZdZdZRS(s An brill templates that generates a list of L{ProximateTokensRule}s that apply at a given sentence position. In particular, each C{ProximateTokensTemplate} is parameterized by a proximate token brill rule class and a list of boundaries, and generates all rules that: - use the given brill rule class - use the given list of boundaries as the C{start} and C{end} points for their conditions - are applicable to the given token. cGsW||_||_x>|D]6\}}||jotd||ffqqWdS(sR Construct a template for generating proximate token brill rules. @type rule_class: C{class} @param rule_class: The proximate token brill rule class that should be used to generate new rules. This class must be a subclass of L{ProximateTokensRule}. @type boundaries: C{tuple} of C{(int, int)} @param boundaries: A list of tuples C{(start, end)}, each of which specifies a range for which a condition should be created by each rule. @raise ValueError: If C{start}>C{end} for any boundary. s Boundary %s has an invalid rangeN(t _rule_classt _boundariesR0(Rt rule_classt boundariesR2R3((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR s    c Cs||d|jogSng}|iD]%\}}||i||||q+~}gg}xC|D];} g} |D]!} | D]} | | | gqqz~ }qiWg} |D]$}| |i||d||q~ S(Ni(Rht_applicable_conditionsRg(RRR*t correct_tagR'RLRMtapplicable_conditionstcondition_combosR1t_[2]told_conditionst new_conditiont_[3]tconds((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRds5  (c Csg}td||}t||dt|}xCt||D]2}|ii||} |i||| fqFW|S(so @return: A set of all conditions for proximate token rules that are applicable to C{tokens[index]}, given boundaries of C{(start, end)}. I.e., return a list of all tuples C{(start, end, M{value})}, such the property value of at least one token between M{index+start} and M{index+end} (inclusive) is M{value}. ii(RJRKR%R$RgRItappend( RRR*RLRMR1R2R3RR\((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRks c Cst|g}xp|iD]e\}}td|| }t|| dt|}x$t||D]}|i|qgWqW|S(Nii(R RhRJRKR%R$R( RRR*t neighborhoodRLRMR2R3R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRes (RRRR RdRkRe(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRfs     t SymmetricProximateTokensTemplatecBs)eZdZdZdZdZRS(s] Simulates two L{ProximateTokensTemplate}s which are symmetric across the location of the token. For rules of the form "If the M{n}th token is tagged C{A}, and any tag preceding B{or} following the M{n}th token by a distance between M{x} and M{y} is C{B}, and ... , then change the tag of the nth token from C{A} to C{C}." One C{ProximateTokensTemplate} is formed by passing in the same arguments given to this class's constructor: tuples representing intervals in which a tag may be found. The other C{ProximateTokensTemplate} is constructed with the negative of all the arguments in reversed order. For example, a C{SymmetricProximateTokensTemplate} using the pair (-2,-1) and the constructor C{SymmetricProximateTokensTemplate} generates the same rules as a C{SymmetricProximateTokensTemplate} using (-2,-1) plus a second C{SymmetricProximateTokensTemplate} using (1,2). This is useful because we typically don't want templates to specify only "following" or only "preceding"; we'd like our rules to be able to look in either direction. cGsWt|||_g}|D]\}}|| | fq~}t|||_dS(sZ Construct a template for generating proximate token brill rules. @type rule_class: C{class} @param rule_class: The proximate token brill rule class that should be used to generate new rules. This class must be a subclass of L{ProximateTokensRule}. @type boundaries: C{tuple} of C{(int, int)} @param boundaries: A list of tuples C{(start, end)}, each of which specifies a range for which a condition should be created by each rule. @raise ValueError: If C{start}>C{end} for any boundary. N(Rft_ptt1t_ptt2(RRiRjR'R2R3treversed((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR s/cCs,|ii||||ii|||S(sm See L{BrillTemplateI} for full specifications. @rtype: list of ProximateTokensRule (RwRdRx(RRR*Rc((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRd)scCs7|ii||}|ii||}|i|S(N(RwReRxtunion(RRR*tn1tn2((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRe2s(RRRR RdRe(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRvs  tBrillTaggerTrainercBsYeZdZdedZdddZdZdZdZd Z d Z RS( s& A trainer for brill taggers. icCsE|djo|dj}n||_||_||_||_dS(s @param deterministic: If true, then choose between rules that have the same score by picking the one whose __repr__ is lexicographically smaller. If false, then just pick the first rule we find with a given score -- this will depend on the order in which keys are returned from dictionaries, and so may not be the same from one run to the next. If not specified, treat as true iff trace > 0. iN(R#Rt _templatest_tracet_deterministic(RRt templatesttracet deterministic((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR @s    iic Cs|idjodt|GHng}|D]}||iit|q.~}|idjo|ing}yxt||jo|i||\}} } |tjp | |jo|idjo dGHnPq|i|d} x'|D]}| t|i |7} qW|idjo|i || | | qqWWn"t j odt|GHnXt |i|S(su Trains the Brill tagger on the corpus C{train_token}, producing at most C{max_rules} transformations, each of which reduces the net number of errors in the corpus by at least C{min_score}. @type train_sents: C{list} of C{list} of L{tuple} @param train_sents: The corpus of tagged tokens @type max_rules: C{int} @param max_rules: The maximum number of transformations to be created @type min_score: C{int} @param min_score: The minimum acceptable net error reduction that each transformation must produce in the corpus. is(Training Brill tagger on %d sentences...iis"Insufficient improvement; stoppings+Training stopped manually -- %d rules found( RR%RR Rt _trace_headert _best_ruleR#RtRt _trace_ruletKeyboardInterruptR( Rt train_sentst max_rulest min_scoreR'tsentt test_sentsR Rtscoretfixscoretk((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyttrainUs0,   #cCstt}xyt|D]k\}}x\t|D]N\}}|d|||djo%|d}||i||fq2q2WqW|i||} d\} } } x&| D]\} }| |jp| |jo|i o| | | fSn|}| i|joqxn|| iD][\}}| i|||o8|d8}|| jp|| jo|i oPqqqqWn|| jp0|| jo;|io1t | t | jo| ||} } } qqW| | | fS(Nii(Nii( RR6R Rtt _find_rulesR#RRR&trepr(RRRtcorrect_indicestsentnumRtwordnumt tagged_wordR R t best_rulet best_scoret best_fixscoreRRR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs:    #      c Csg}xkt|D]]\}}xNt|D]@\}}|d|||djo|i||fq,q,WqWtt}xX|D]P\}}||} ||} x-|i| | |D]} || cd7s(R RtRtintt_find_rules_attsortedtitems( RRRt error_indicesRRRRtrule_score_dictt test_sentt train_sentR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs"       cCsrt}||d||djoH||d}x7|iD](}|i|||}|i|q>Wn|S(s @rtype: C{Set} @return: the set of all rules (based on the templates) that correct token C{i}'s tag in C{test_sent}. i(R R~Rdtupdate(RRRRRdRlttemplatet new_rules((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs    cCsdiGHdS(Ns B | S F r O | Score = Fixed - Broken c i o t | R Fixed = num tags changed incorrect -> correct o x k h | u Broken = num tags changed correct -> incorrect r e e e | l Other = num tags changed incorrect -> incorrect e d n r | e ------------------+------------------------------------------------------- (trstrip(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs c Csu|idjo\d||||||d|fGdGtit|dd ddd d d iGHn|GHdS(Nis %4d%4d%4d%4d t|tinitial_indentt itwidthiOtsubsequent_indentis| s s (RttextwraptfillR=tstrip(RRRRt numchanges((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs ( RRRR#R RRRRRR(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR}<s < 6 !  tFastBrillTaggerTrainercBseZdZdedZdddZdZdZdZd Z d Z d Z d Z d Z dZdZdZdZdZRS(s- A faster trainer for brill taggers. icCs{|djo|dj}n||_||_||_||_d|_d|_d|_d|_d|_ d|_ dS(Ni( R#RR~RRt_tag_positionst_rules_by_positiont_positions_by_rulet_rules_by_scoret _rule_scorest_first_unknown_position(RRRRR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR s         iic Cs|idjodt|GHng}|D]}||iit|q.~}|idjo dGHn|i|||idjodt|iGHn|idjo|in|idjo dGHng}yxt||jo|i|||}|o|i |nP|idjo|i |n|i |||i ||i |||qWWn"tj odt|GHnX|it|i|S( Nis(Training Brill tagger on %d sentences...sFinding initial useful rules...s Found %d useful rules.iisSelecting rules...s+Training stopped manually -- %d rules found(RR%RR Rt_init_mappingsRRRRtRt _apply_rulet_update_tag_positionst _update_rulesRt_cleanR( RRRRR'RRR R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRHs2,!  c Cstt|_tt|_tt|_tt|_tt|_ tt|_ xt |D]\}}xt |D]\}\}}|i|i ||f|||d}||jo:x7|i |||D]} |i| |||qWqqWqgWdS(s Initialize the tag position mapping & the rule related mappings. For each error in test_sents, find new rules that would correct them, and add them to the rule mappings. iN(RR6RR RR<RRRRRR RtRt_update_rule_applies( RRRRRRtwordR RlR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs"   cCs:d|_d|_d|_d|_d|_d|_dS(N(R#RRRRRR(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs      ccs=x6|iD]+}x"|i|||D] }|Vq&Wq WdS(s Use the templates to find rules that apply at index C{wordnum} in the sentence C{sent} and generate the tag C{new_tag}. N(R~Rd(RRRtnew_tagRR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs  cCs||f}||i|jodSn|||d}|i|jod|i|| correct o x k h | u Broken = num tags changed correct -> incorrect r e e e | l Other = num tags changed incorrect -> incorrect e d n r | e ------------------+------------------------------------------------------- (R(R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRrs c Cs]|i|t|i|ijpt|i|i}t|}tg}|D]}|djo ||q[q[~}tg}|D]}|djo ||qq~}tg} |D]}|djo | |qq~ } |i|} |idjoBd| ||| fGtit |dd d d d i GHn|GHdS(Niiiis%4d%4d%4d%4d |RRiRis| s s ( RtsumRtvaluesR"R%RRRR=R( RRtchangest num_changedR'RWt num_fixedRot num_brokenRrt num_otherR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyR}s $ 888 cCsd}|GH|Gd|GHdS(NRiRsApplying rule to %d positions.s s |((Rt num_updatestprefix((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRscCs8d}|GdGH|Gd|GH|Gd||fGH|GHdS( NRiRsUpdated rule tables:s - %d rule applications removeds) - %d rule applications added (%d novel)s s |((RRRRR((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs    (RRRR#R RRRRRRRRRRRRRR(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyRs" /<    /   =  ic Cs'dddddddddddidd f}|g}xt||D]\}}xt|D]\}\}} ||d } | | jod id || D} d id ||d D} d|| | f} |id| d| id| d fqnqnWqUW|S(s1 Returns a list of human-readable strings indicating the errors in the given tagging of the corpus. @param train_sents: The correct tagging of the corpus @type train_sents: C{list} of C{tuple} @param test_sents: The tagged corpus @type test_sents: C{list} of C{tuple} @param radius: How many tokens on either side of a wrongly-tagged token to include in the error string. For example, if C{radius}=2, each error string will show the incorrect token plus two tokens on either side. @type radius: int s%25s | %s | %s t-it+is left contextsword/test->goldis right contextiRcssx|]}d|VqWdS(s%s/%sN((R7tw((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pys scssx|]}d|VqWdS(s%s/%sN((R7R((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pys ss %s/%s->%ss%25s | %s | %sii(tcentertzipR RSRt(RRtradiusthdrterrorsRRRRt train_posttest_postlefttrighttmid((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pyt error_lists#    ! .idiis errors.outs rules.yamlg?cCsCddkl}ddkl} ddkl} | iddg} d GH|i} |o$ti t t ti t nt ||} | | }| | |!}g}|D],}|g}|D]}||d q~q~}d GHd GH| i|d | }|od| i||GHndGH| i|d |}|od| i||GHn| i| id| i| id| i| id| i| id| i| id | i| id!| i| id"| i| id#| i| id$d%| i| id&d'g }| i|||}|i|||}|od| i||GHn|djo+dGHx#|iD]}t|GHqWnt|d}ti|||i|i|}t|d}|id|x(t||D]}|i|dq W|id||fGHdS((sp Brill Tagger Demonstration @param num_sents: how many sentences of training and testing data to use @type num_sents: L{int} @param max_rules: maximum number of rule instances to create @type max_rules: L{int} @param min_score: the minimum score for a rule in order for it to be considered @type min_score: L{int} @param error_output: the file where errors will be saved @type error_output: C{string} @param rule_output: the file where rules will be saved @type rule_output: C{string} @param randomize: whether the training data should be a random subset of the corpus @type randomize: boolean @param train: the fraction of the the corpus to be used for training (1=all) @type train: L{float} @param trace: the level of diagnostic tracing output to produce (0-4) @type trace: L{int} i(ttreebank(R (tbrills^-?[0-9]+(.[0-9]+)?$tCDs.*tNNsLoading tagged data... is Done loading.sTraining unigram tagger:tbackoffs [accuracy: %f]sTraining bigram tagger:iiis Brill accuracy: %fs Rules: RsErrors for Brill Tagger %r s s*Done; rules and errors saved to %s and %s.N(s^-?[0-9]+(.[0-9]+)?$sCD(s.*sNN(ii(ii(ii(ii(ii(ii(ii(ii(ii(ii(ii(ii( t nltk.corpusRtnltkR tnltk.tagRt RegexpTaggert tagged_sentstrandomtseedR%tsentstshuffleRt UnigramTaggertaccuracyt BigramTaggerRvR_R`RfRRR R=tfiletyamltdumptcloset batch_tagtwriteR(t num_sentsRRt error_outputt rule_outputt randomizeRRRR Rt nn_cd_taggert tagged_datatcutofft training_datat gold_dataR'RRottt testing_datatunigram_taggert bigram_taggerRttrainert brill_taggerRt print_rulest error_fileR3((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pytdemosp     @        t__main__(RRRRRRRtutilRtapitTaggerIt YAMLObjectRR R.R_R`tobjectRbRfRvR}RRR)RR(((s$/p/zhu/06/nlp/nltk/nltk/tag/brill.pys s0     =L /[= " a