ó ù`]c@sadZddlmZmZyddlZWnek r?nXddlZddlZddlm Z ddl m Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZmZmZdd lmZmZmZdd lmZm Z m!Z!dZ"e j#defd„ƒYƒZ$e$Z%de&fd„ƒYZ'de'fd„ƒYZ(de'fd„ƒYZ)de)fd„ƒYZ*de)fd„ƒYZ+de'fd„ƒYZ,de-e-d„Z.d„Z/d „Z0de-e-d!„Z1d"„Z2d#„Z3de-e-d$d%„Z4d&e$fd'„ƒYZ5d(„Z6e7d)kr]e6ƒndS(*uä A classifier model based on maximum entropy modeling framework. This framework considers all of the probability distributions that are empirically consistent with the training data; and chooses the distribution with the highest entropy. A probability distribution is "empirically consistent" with a set of training data if its estimated frequency with which a class and a feature vector value co-occur is equal to the actual frequency in the data. Terminology: 'feature' ====================== The term *feature* is usually used to refer to some property of an unlabeled token. For example, when performing word sense disambiguation, we might define a ``'prevword'`` feature whose value is the word preceding the target word. However, in the context of maxent modeling, the term *feature* is typically used to refer to a property of a "labeled" token. In order to prevent confusion, we will introduce two distinct terms to disambiguate these two different concepts: - An "input-feature" is a property of an unlabeled token. - A "joint-feature" is a property of a labeled token. In the rest of the ``nltk.classify`` module, the term "features" is used to refer to what we will call "input-features" in this module. In literature that describes and discusses maximum entropy models, input-features are typically called "contexts", and joint-features are simply referred to as "features". Converting Input-Features to Joint-Features ------------------------------------------- In maximum entropy models, joint-features are required to have numeric values. Typically, each input-feature ``input_feat`` is mapped to a set of joint-features of the form: | joint_feat(token, label) = { 1 if input_feat(token) == feat_val | { and label == some_label | { | { 0 otherwise For all values of ``feat_val`` and ``some_label``. This mapping is performed by classes that implement the ``MaxentFeatureEncodingI`` interface. iÿÿÿÿ(tprint_functiontunicode_literalsN(t defaultdict(t integer_types(tcompat(tgzip_open_unicode(t OrderedDict(tDictionaryProbDist(t ClassifierI(t CutoffCheckertaccuracytlog_likelihood(t call_megamtwrite_megam_filetparse_megam_weights(t call_tadmtwrite_tadm_filetparse_tadm_weightsu epytext entMaxentClassifiercBs§eZdZed„Zd„Zd„Zd„Zd„Zd„Z dd„Z d d „Z d d d „Z d „Z ddddgZedddddd„ƒZRS(uî A maximum entropy classifier (also known as a "conditional exponential classifier"). This classifier is parameterized by a set of "weights", which are used to combine the joint-features that are generated from a featureset by an "encoding". In particular, the encoding maps each ``(featureset, label)`` pair to a vector. The probability of each label is then computed using the following equation:: dotprod(weights, encode(fs,label)) prob(fs|label) = --------------------------------------------------- sum(dotprod(weights, encode(fs,l)) for l in labels) Where ``dotprod`` is the dot product:: dotprod(a,b) = sum(x*y for (x,y) in zip(a,b)) cCs=||_||_||_|jƒt|ƒks9t‚dS(u{ Construct a new maxent classifier model. Typically, new classifier models are created using the ``train()`` method. :type encoding: MaxentFeatureEncodingI :param encoding: An encoding that is used to convert the featuresets that are given to the ``classify`` method into joint-feature vectors, which are used by the maxent classifier model. :type weights: list of float :param weights: The feature weight vector for this classifier. :type logarithmic: bool :param logarithmic: If false, then use non-logarithmic weights. N(t _encodingt_weightst _logarithmictlengthtlentAssertionError(tselftencodingtweightst logarithmic((s3lib/python2.7/site-packages/nltk/classify/maxent.pyt__init__hs   cCs |jjƒS(N(Rtlabels(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRscCs.||_|jjƒt|ƒks*t‚dS(u¨ Set the feature weight vector for this classifier. :param new_weights: The new feature weight vector. :type new_weights: list of float N(RRRRR(Rt new_weights((s3lib/python2.7/site-packages/nltk/classify/maxent.pyt set_weights‚s cCs|jS(ug :return: The feature weight vector for this classifier. :rtype: list of float (R(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR‹scCs|j|ƒjƒS(N(t prob_classifytmax(Rt featureset((s3lib/python2.7/site-packages/nltk/classify/maxent.pytclassify’sc CsÒi}x°|jjƒD]Ÿ}|jj||ƒ}|jryd}x)|D]!\}}||j||7}qGW|||·su u-icstˆj|dƒS(Ni(tabsR(tfid__(R(s3lib/python2.7/site-packages/nltk/classify/maxent.pyt¾tu and label is iu (%s)i/i,u...u iu TOTAL:c3s|]}dˆ|VqdS(u%8.3fN((R2R3(tsums(s3lib/python2.7/site-packages/nltk/classify/maxent.pys Îsu PROBS:c3s"|]}dˆj|ƒVqdS(u%8.3fN(tprob(R2R3(tpdist(s3lib/python2.7/site-packages/nltk/classify/maxent.pys ÒsN(tstrR!tsortedtsamplesR9R(tprinttljusttjoinRRtintt enumerateRR'tsortRRtdescribetsplit( RR#tcolumnst descr_widthtTEMPLATERtiR*R+R-R.tscoretdescr((R:RR8s3lib/python2.7/site-packages/nltk/classify/maxent.pytexplain©s>!  $   $- i csbtˆdƒrˆj| Sttttˆjƒƒƒd‡fd†dtƒˆ_ˆj| SdS(uW Generates the ranked list of informative features from most to least. u_most_informative_featuresR0cstˆj|ƒS(N(R4R(tfid(R(s3lib/python2.7/site-packages/nltk/classify/maxent.pyR6ÞR7R1N(thasattrt_most_informative_featuresR<tlisttrangeRRR((Rtn((Rs3lib/python2.7/site-packages/nltk/classify/maxent.pytmost_informative_featuresÕs  uallcCsÅ|jdƒ}|dkrJg|D]}|j|dkr"|^q"}n;|dkr…g|D]}|j|dkr]|^q]}nx9|| D]-}td|j||jj|ƒfƒqWdS(u« :param show: all, neg, or pos (for negative-only or positive-only) :type show: str :param n: The no. of top features :type n: int uposiunegu%8.3f %sN(RStNoneRR>RRD(RRRtshowtfidsRM((s3lib/python2.7/site-packages/nltk/classify/maxent.pytshow_most_informative_featuresãs / /cCs&dt|jjƒƒ|jjƒfS(Nu:(RRRR(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyt__repr__ósuGISuIISuMEGAMuTADMiic Ks|dkrd}nx-|D]%}|dkrtd |ƒ‚qqW|jƒ}|dkrst|||||S|d kr•t|||||S|d krºt||||||S|dkr|} || d<|| d<|| d<|| d             N(t__name__t __module__t__doc__R(RRR RR$R!RLRSRWRXt ALGORITHMSt classmethodRTR_(((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRTs$      ,  tMaxentFeatureEncodingIcBs;eZdZd„Zd„Zd„Zd„Zd„ZRS(u´ A mapping that converts a set of input-feature values to a vector of joint-feature values, given a label. This conversion is necessary to translate featuresets into a format that can be used by maximum entropy models. The set of joint-features used by a given encoding is fixed, and each index in the generated joint-feature vectors corresponds to a single joint-feature. The length of the generated joint-feature vectors is therefore constant (for a given encoding). Because the joint-feature vectors generated by ``MaxentFeatureEncodingI`` are typically very sparse, they are represented as a list of ``(index, value)`` tuples, specifying the value of each non-zero joint-feature. Feature encodings are generally created using the ``train()`` method, which generates an appropriate encoding based on the input-feature values and labels that are present in a given corpus. cCs tƒ‚dS(uC Given a (featureset, label) pair, return the corresponding vector of joint-feature values. This vector is represented as a list of ``(index, value)`` tuples, specifying the value of each non-zero joint-feature. :type featureset: dict :rtype: list(tuple(int, int)) N(tNotImplementedError(RR#R*((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR'‚s cCs tƒ‚dS(u’ :return: The size of the fixed-length joint-feature vectors that are generated by this encoding. :rtype: int N(Rn(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRŽscCs tƒ‚dS(uÞ :return: A list of the "known labels" -- i.e., all labels ``l`` such that ``self.encode(fs,l)`` can be a nonzero joint-feature vector for some value of ``fs``. :rtype: list N(Rn(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR–scCs tƒ‚dS(u¦ :return: A string describing the value of the joint-feature whose index in the generated feature vectors is ``fid``. :rtype: str N(Rn(RRM((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRDŸscCs tƒ‚dS(uo Construct and return new feature encoding, based on a given training corpus ``train_toks``. :type train_toks: list(tuple(dict, str)) :param train_toks: Training data, represented as a list of pairs, the first member of which is a feature dictionary, and the second of which is a classification label. N(Rn(RaRb((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR_§s (RhRiRjR'RRRDR_(((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRmks   t#FunctionBackedMaxentFeatureEncodingcBs;eZdZd„Zd„Zd„Zd„Zd„ZRS(u‹ A feature encoding that calls a user-supplied function to map a given featureset/label pair to a sparse joint-feature vector. cCs||_||_||_dS(ug Construct a new feature encoding based on the given function. :type func: (callable) :param func: A function that takes two arguments, a featureset and a label, and returns the sparse joint feature vector that encodes them:: func(featureset, label) -> feature_vector This sparse joint feature vector (``feature_vector``) is a list of ``(index,value)`` tuples. :type length: int :param length: The size of the fixed-length joint-feature vectors that are generated by this encoding. :type labels: list :param labels: A list of the "known labels" for this encoding -- i.e., all labels ``l`` such that ``self.encode(fs,l)`` can be a nonzero joint-feature vector for some value of ``fs``. N(t_lengtht_funct_labels(RtfuncRR((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRºs  cCs|j||ƒS(N(Rq(RR#R*((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR'ÖscCs|jS(N(Rp(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRÙscCs|jS(N(Rr(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRÜscCsdS(Nuno description available((RRM((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRDßs(RhRiRjRR'RRRD(((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRo´s     tBinaryMaxentFeatureEncodingcBsVeZdZeed„Zd„Zd„Zd„Zd„Ze ddd„ƒZ RS( uø A feature encoding that generates vectors containing a binary joint-features of the form: | joint_feat(fs, l) = { 1 if (fs[fname] == fval) and (l == label) | { | { 0 otherwise Where ``fname`` is the name of an input-feature, ``fval`` is a value for that input-feature, and ``label`` is a label. Typically, these features are constructed based on a training corpus, using the ``train()`` method. This method will create one feature for each combination of ``fname``, ``fval``, and ``label`` that occurs at least once in the training corpus. The ``unseen_features`` parameter can be used to add "unseen-value features", which are used whenever an input feature has a value that was not encountered in the training corpus. These features have the form: | joint_feat(fs, l) = { 1 if is_unseen(fname, fs[fname]) | { and l == label | { | { 0 otherwise Where ``is_unseen(fname, fval)`` is true if the encoding does not contain any joint features that are true when ``fs[fname]==fval``. The ``alwayson_features`` parameter can be used to add "always-on features", which have the form:: | joint_feat(fs, l) = { 1 if (l == label) | { | { 0 otherwise These always-on features allow the maxent model to directly model the prior probabilities of each label. cst|jƒƒttt|ƒƒƒkr9tdƒ‚nt|ƒˆ_|ˆ_t|ƒˆ_dˆ_ dˆ_ |r¸t ‡fd†t |ƒDƒƒˆ_ ˆjtˆj ƒ7_n|rtd„|Dƒƒ}t ‡fd†t |ƒDƒƒˆ_ ˆjt|ƒ7_ndS(u» :param labels: A list of the "known labels" for this encoding. :param mapping: A dictionary mapping from ``(fname,fval,label)`` tuples to corresponding joint-feature indexes. These indexes must be the set of integers from 0...len(mapping). If ``mapping[fname,fval,label]=id``, then ``self.encode(..., fname:fval, ..., label)[id]`` is 1; otherwise, it is 0. :param unseen_features: If true, then include unseen value features in the generated joint-feature vectors. :param alwayson_features: If true, then include always-on features in the generated joint-feature vectors. uHMapping values must be exactly the set of integers from 0...len(mapping)c3s(|]\}}||ˆjfVqdS(N(Rp(R2RIR*(R(s3lib/python2.7/site-packages/nltk/classify/maxent.pys 4scss|]\}}}|VqdS(N((R2tfnametfvalR*((s3lib/python2.7/site-packages/nltk/classify/maxent.pys 9sc3s(|]\}}||ˆjfVqdS(N(Rp(R2RIRu(R(s3lib/python2.7/site-packages/nltk/classify/maxent.pys ;sN(tsettvaluesRQRR`RPRrt_mappingRpRTt _alwaysont_unseentdictRB(RRtmappingtunseen_featurestalwayson_featurestfnames((Rs3lib/python2.7/site-packages/nltk/classify/maxent.pyR s"*    ""cCsg}xÀ|jƒD]²\}}|||f|jkr]|j|j|||fdfƒq|jrx\|jD]"}|||f|jkrpPqpqpW||jkrÅ|j|j|dfƒqÅqqW|jrþ||jkrþ|j|j|dfƒn|S(Ni(titemsRytappendR{RrRz(RR#R*RRuRvtlabel2((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR'?s& $cCsyt|tƒstdƒ‚ny |jWnWtk r‚dgt|jƒ|_x.|jjƒD]\}}||j|ÌsiN(RtRRTRRwt_C(RRR}R~RtC((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR¿s  #cCs|jS(uOThe non-negative constant that all encoded feature vectors will sum to.(R‘(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR’ÏscCsvtj|||ƒ}tj|ƒ}td„|Dƒƒ}||jkrXtdƒ‚n|j||j|fƒ|S(Ncss|]\}}|VqdS(N((R2tftv((s3lib/python2.7/site-packages/nltk/classify/maxent.pys Ûsu&Correction feature is not high enough!(RtR'RtsumR‘R`R‚(RR#R*Rt base_lengthR,((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR'ÕscCstj|ƒdS(Ni(RtR(R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRãscCs4|tj|ƒkr d|jStj||ƒSdS(NuCorrection feature (%s)(RtRR‘RD(RR-((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRDæs N( RhRiRjRRTRtpropertyR’R'RRD(((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR°s    tTadmEventMaxentFeatureEncodingcBsPeZeed„Zd„Zd„Zd„Zd„Zeddd„ƒZ RS(cCs;t|ƒ|_tƒ|_tj|||j||ƒdS(N(RRyt_label_mappingRtR(RRR}R~R((s3lib/python2.7/site-packages/nltk/classify/maxent.pyRîs cCsÉg}x¼|jƒD]®\}}||f|jkrSt|jƒ|j||f†scss|]\}}}|VqdS(N((R2RuRvR*((s3lib/python2.7/site-packages/nltk/classify/maxent.pys ‹sc3s(|]\}}||ˆjfVqdS(N(Rp(R2RIRu(R(s3lib/python2.7/site-packages/nltk/classify/maxent.pys sN(RwRxRQRR`RPRrRyRpRTRzR{R|RB(RRR}R~RR€((Rs3lib/python2.7/site-packages/nltk/classify/maxent.pyR^s"*    ""cCsdg}x"|jƒD]\}}t|ttfƒr|t|ƒ|f|jkr'|j|j|t|ƒ|f|fƒq'q|||f|jkr¿|j|j|||fdfƒq|jrx\|jD]"}|||f|jkrÒPqÒqÒW||jkr'|j|j|dfƒq'qqW|j r`||j kr`|j|j |dfƒn|S(Ni( RR„RtfloatttypeRyR‚R{RrRz(RR#R*RRuRvRƒ((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR'‘s /& $cCsyt|tƒstdƒ‚ny |jWnWtk r‚dgt|jƒ|_x.|jjƒD]\}}||j| Training (%d iterations)iu- Iteration Log Likelihood Accuracyu- ---------------------------------------u %9d %14.5f %9.3fiu* Training stopped: keyboard interruptu! Final %14.5f %9.3fN(t setdefaultR RTRR_RNRYR’tcalculate_empirical_fcountRwtnumpytnonzerotzerosRtNINFt ConditionalExponentialClassifiertlog2R>R(tllR taccR titertcalculate_estimated_fcountRR tchecktKeyboardInterrupt(RbRdRRRft cutoffcheckertCinvtempirical_fcountt unattestedRRMt classifiertlog_empirical_fcountR§R¨titernumtestimated_fcounttlog_estimated_fcount((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR\sb                    cCsftj|jƒdƒ}xG|D]?\}}x0|j||ƒD]\}}||c|7WqW|S(Nud(R¡R£RR'(RbRtfcountRŽR*tindextval((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR rs c CsŸtj|jƒdƒ}x€|D]x\}}|j|ƒ}xZ|jƒD]L}|j|ƒ}x4|j||ƒD] \}} ||c|| 7 Training (%d iterations)iu- Iteration Log Likelihood Accuracyu- ---------------------------------------u %9d %14.5f %9.3fu* Training stopped: keyboard interruptu! Final %14.5f %9.3fN(RŸR RTRtR_R Rtcalculate_nfmapR¡tarrayR<t __getitem__treshapeRwR¢R£R¤R¥R>R(R§R R¨R R©tcalculate_deltasRR R«R¬(RbRdRRRfR­tempirical_ffreqtnfmaptnfarrayt nftransposeR°RRMR±R§R¨R³tdeltas((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR[Žsb   !                cCsztƒ}xT|D]L\}}x=|jƒD]/}|jtd„|j||ƒDƒƒƒq)WqWtd„t|ƒDƒƒS(uó Construct a map that can be used to compress ``nf`` (which is typically sparse). *nf(feature_vector)* is the sum of the feature values for *feature_vector*. This represents the number of features that are active for a given labeled text. This method finds all values of *nf(t)* that are attested for at least one token in the given list of training tokens; and constructs a dictionary mapping these attested values to a continuous range *0...N*. For example, if the only values of *nf()* that were attested were 3, 5, and 7, then ``_nfmap`` might return the dictionary ``{3:0, 5:1, 7:2}``. :return: A map that can be used to compress ``nf`` to a dense vector. :rtype: dict(int -> int) css|]\}}|VqdS(N((R2tidR¸((s3lib/python2.7/site-packages/nltk/classify/maxent.pys scss!|]\}}||fVqdS(N((R2RItnf((s3lib/python2.7/site-packages/nltk/classify/maxent.pys s(RwRR‰R•R'R|RB(RbRtnfsetRŽt_R*((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR¹ês  1cCsÞd}d} tj|jƒdƒ} tjt|ƒ|jƒfdƒ} x |D]˜\} } |j| ƒ}xz|jƒD]l} |j| | ƒ}td„|Dƒƒ}x;|D]3\}}| |||fc|j | ƒ|7 int) :param nfarray: An array that can be used to uncompress ``nf`` from a dense vector. :type nfarray: array(float) :param nftranspose: The transpose of ``nfarray`` :type nftranspose: array(float) gê-™—q=i,udcss|]\}}|VqdS(N((R2RÃR¸((s3lib/python2.7/site-packages/nltk/classify/maxent.pys `sitaxisii( R¡tonesRR£RR!RR'R•R9RQtouterR4(RbR±R°tffreq_empiricalR¿RÀRÁRtNEWTON_CONVERGEt MAX_NEWTONRÂtARŽR*tdistR+RÄRÃR¸trangenumtnf_deltat exp_nf_deltatnf_exp_nf_deltatsum1tsum2RMtn_error((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR½s2I$3    , ic KsÄt}t}d|kr%|d}nd|kr>|d}n|d kr}|jddƒ}tj||d|dtƒ}n|d k r˜tdƒ‚ny]tjdd ƒ\} } t| d ƒ#} t ||| d |d |ƒWd QXt j | ƒWn,t t tfk r#} td| ƒ‚nXg} | dddg7} |rS| dg7} n|si| dg7} n|r€d|d}nd}| dd|dg7} |dkr¹| dg7} nd|krà| dd|dg7} nd|kr | ddt|dƒg7} nt|d ƒr,| d!g7} n| d"| g7} t| ƒ}yt j| ƒWn-t t fk rˆ} td#| | fƒnXt||jƒ|ƒ}|tjtjƒ9}t||ƒS($u› Train a new ``ConditionalExponentialClassifier``, using the given training samples, using the external ``megam`` library. This ``ConditionalExponentialClassifier`` will encode the model that maximizes entropy from all the models that are empirically consistent with ``train_toks``. :see: ``train_maxent_classifier()`` for parameter descriptions. :see: ``nltk.classify.megam`` uexplicitu bernoulliu count_cutoffiRRu$Specify encoding or labels, not bothtprefixunltk-uwtexplicitt bernoulliNu,Error while creating megam training file: %su-nobiasu-repeatu10u -explicitu-fvalsgð?iu-lambdau%.2fu-tuneiu-quietumax_iteru-maxiu%sull_deltau-dppucostu -multilabelu multiclassu Warning: unable to delete %s: %s(R(RTtgetRtR_R`ttempfiletmkstemptopenR tostclosetOSErrortIOErrorR4RNR tremoveR>RRR¡R¦teR(RbRdRRReRgR×RØRŠtfdttrainfile_namet trainfileRâR‹t inv_variancetstdoutR((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR]Œs^         ! R^cBseZed„ƒZRS(cKs]|jddƒ}|jddƒ}|jddƒ}|jddƒ}|jddƒ}|jd dƒ}|jd ƒ} |jd ƒ} |s«tj||d |ƒ}ntjd dddƒ\} } tjd dƒ\} }t| dƒ}t|||ƒ|jƒg}|j dgƒ|j d|gƒ|rW|j dd|dgƒn| rw|j dd| gƒn| r|j ddt | ƒgƒn|j d| gƒ|j d|gƒ|dkrâ|j dgƒn|j dgƒt |ƒt |dƒ}t |ƒ}WdQXtj| ƒtj|ƒ|tjtjƒ9}|||ƒS( Nu algorithmutao_lmvmutraceiuencodingulabelsugaussian_prior_sigmaiu count_cutoffumax_iteru min_lldeltaRRÖunltk-tadm-events-tsuffixu.gzunltk-tadm-weights-uwu-monitoru-methodu-l2u%.6fiu-max_itu%du-fatolu -events_inu -params_outu2>&1u-summaryur(RÙRTR˜R_RÚRÛRRRÞtextendR4RRÜRRÝRáR¡R¦Râ(RaRbRgRcRdRRtsigmaRŠtmax_itertll_deltat trainfile_fdRät weightfile_fdtweightfile_nameRåR‹t weightfileR((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR_ésL       (RhRiRlR_(((s3lib/python2.7/site-packages/nltk/classify/maxent.pyR^èscCs#ddlm}|tjƒ}dS(Niÿÿÿÿ(t names_demo(tnltk.classify.utilRñRR_(RñR±((s3lib/python2.7/site-packages/nltk/classify/maxent.pytdemo%su__main__(8Rjt __future__RRR¡t ImportErrorRÚRÝt collectionsRtsixRtnltkRt nltk.dataRt nltk.utilRtnltk.probabilityRtnltk.classify.apiRRòR R R tnltk.classify.megamR R Rtnltk.classify.tadmRRRt __docformat__tpython_2_unicode_compatibleRR¥tobjectRmRoRtRR˜RœRTR\R RªR[R¹R½R]R^RóRh(((s3lib/python2.7/site-packages/nltk/classify/maxent.pyt5sN    ÿI/Í=8ìa [  ‡[=