o rZh@sdZzddlZWn eyYnwddlZddlZddlmZddlmZddl m Z m Z m Z ddl mZmZmZddlmZmZmZddlmZdd lmZdd lmZd ZGd d d eZeZGdddZGdddeZGdddeZ Gddde Z!Gddde Z"GdddeZ# d5ddZ$ddZ%dd Z& d5d!d"Z'd#d$Z(d%d&Z) d6d'd(Z*Gd)d*d*eZ+d+d,Z,d7d.d/Z-d0d1Z.d2d3Z/e0d4kre/dSdS)8a 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. N) defaultdict) ClassifierI) call_megamparse_megam_weightswrite_megam_file) call_tadmparse_tadm_weightswrite_tadm_file) CutoffCheckeraccuracylog_likelihood)gzip_open_unicode)DictionaryProbDist) OrderedDictz epytext enc@seZdZdZd ddZddZddZd d Zd d Zd dZ d!ddZ d"ddZ d#ddZ ddZ gdZe     d$ddZdS)%MaxentClassifiera 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)) TcCs*||_||_||_|t|ksJdS)a{ 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) _encoding_weights _logarithmiclengthlen)selfencodingweightsZ logarithmicrC/var/www/auris/lib/python3.10/site-packages/nltk/classify/maxent.py__init__aszMaxentClassifier.__init__cCs |jSN)rlabelsrrrrrx zMaxentClassifier.labelscCs ||_|jt|ksJdS)z Set the feature weight vector for this classifier. :param new_weights: The new feature weight vector. :type new_weights: list of float N)rrrr)rZ new_weightsrrr set_weights{szMaxentClassifier.set_weightscC|jS)zg :return: The feature weight vector for this classifier. :rtype: list of float rrrrrrszMaxentClassifier.weightscCs||Sr) prob_classifymax)r featuresetrrrclassifyzMaxentClassifier.classifyc Csi}|jD]9}|j||}|jr*d}|D] \}}||j||7}q|||<qd}|D] \}}||j||9}q.|||<qt||jddS)Ng?T)log normalize)rrencoderrr) rr%Z prob_dictlabelfeature_vectortotalf_idf_valprodrrrr#s    zMaxentClassifier.prob_classifyc sd}dt|dd}|tjdd}|d|}td|d d d |Dtd d |ddt|t t t |D]e\}}j ||}|jfdddd|D]L\} } jrqj| | } nj| | } j | } | dd} | d| 7} t| dkr| ddd} t|| |dd| f|| 7<qbqJtd d |ddt|td|d fdd |Dtd|d fdd |DdS)z Print a table showing the effect of each of the features in the given feature set, and how they combine to determine the probabilities of each label for that featureset. 2z %-zs%s%8.3fTkeyreverseNz Featurecss$|] }dd|ddVqdS)z%8s%sNr.0lrrr s"z+MaxentClassifier.explain..z -cstj|dS)Nrabsr)Zfid__rrrsz*MaxentClassifier.explain.. and label is rz (%s)/,z... z TOTAL:c3s|] }d|VqdSz%8.3fNrr;)sumsrrr>sz PROBS:c3s|] }d|VqdSrI)probr;)pdistrrr>s)strr#sortedsamplesrKprintljustjoinrrint enumeraterr+sortrrdescribesplit) rr%columnsZ descr_widthTEMPLATErir,r-r/r0Zscoredescrr)rLrrJrexplainsL          zMaxentClassifier.explain csLtdr jd|Sttttjfdddd_jd|S)zW Generates the ranked list of informative features from most to least. _most_informative_featuresNcstj|SrrA)fidrrrrCsz.Tr5)hasattrr^rNlistrangerr)rnrrrmost_informative_featuress  z*MaxentClassifier.most_informative_featuresallcsxd}|dkrfdd|D}n |dkr fdd|D}|d|D]}tj|ddj|q&dS) z :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 Nposcsg|] }j|dkr|qSrr"r<r_rrr zCMaxentClassifier.show_most_informative_features..negcsg|] }j|dkr|qSrgr"rhrrrrirjz8.3frG)rdrPrrrV)rrcshowZfidsr_rrrshow_most_informative_featuress $z/MaxentClassifier.show_most_informative_featurescCsdt|j|jfS)Nz:)rrrrrrrr__repr__s zMaxentClassifier.__repr__)ZGISZIISZMEGAMZTADMNrc Ks|durd}|D] }|dvrtd|q|}|dkr(t||||fi|S|dkr7t||||fi|S|dkrGt|||||fi|S|dkrf|} || d<|| d <|| d <|| d <tj|fi| Std |) a Train a new maxent classifier based on the given corpus of training samples. This classifier will have its weights chosen to maximize entropy while remaining empirically consistent with the training corpus. :rtype: MaxentClassifier :return: The new maxent classifier :type train_toks: list :param train_toks: Training data, represented as a list of pairs, the first member of which is a featureset, and the second of which is a classification label. :type algorithm: str :param algorithm: A case-insensitive string, specifying which algorithm should be used to train the classifier. The following algorithms are currently available. - Iterative Scaling Methods: Generalized Iterative Scaling (``'GIS'``), Improved Iterative Scaling (``'IIS'``) - External Libraries (requiring megam): LM-BFGS algorithm, with training performed by Megam (``'megam'``) The default algorithm is ``'IIS'``. :type trace: int :param trace: The level of diagnostic tracing output to produce. Higher values produce more verbose output. :type encoding: MaxentFeatureEncodingI :param encoding: A feature encoding, used to convert featuresets into feature vectors. If none is specified, then a ``BinaryMaxentFeatureEncoding`` will be built based on the features that are attested in the training corpus. :type labels: list(str) :param labels: The set of possible labels. If none is given, then the set of all labels attested in the training data will be used instead. :param gaussian_prior_sigma: The sigma value for a gaussian prior on model weights. Currently, this is supported by ``megam``. For other algorithms, its value is ignored. :param cutoffs: Arguments specifying various conditions under which the training should be halted. (Some of the cutoff conditions are not supported by some algorithms.) - ``max_iter=v``: Terminate after ``v`` iterations. - ``min_ll=v``: Terminate after the negative average log-likelihood drops under ``v``. - ``min_lldelta=v``: Terminate if a single iteration improves log likelihood by less than ``v``. NZiis) max_iterZmin_ll min_lldeltaZmax_accZ min_accdelta count_cutoffZnormexplicit bernoullizUnexpected keyword arg %rZgisZmegamZtadmtracerrgaussian_prior_sigmazUnknown algorithm %s) TypeErrorlower train_maxent_classifier_with_iis train_maxent_classifier_with_gis"train_maxent_classifier_with_megamTadmMaxentClassifiertrain ValueError) cls train_toks algorithmrurrrvcutoffsr6kwargsrrrr}sB>    zMaxentClassifier.train)T)r2)r])r]re)NroNNr)__name__ __module__ __qualname____doc__rrr rr&r#r\rdrmrnZ ALGORITHMS classmethodr}rrrrrNs(    , rc@8eZdZdZddZddZddZdd Zd d Zd S) MaxentFeatureEncodingIa 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. cCt)aC 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)) NotImplementedErrorrr%r,rrrr+{ zMaxentFeatureEncodingI.encodecCr)z :return: The size of the fixed-length joint-feature vectors that are generated by this encoding. :rtype: int rrrrrrzMaxentFeatureEncodingI.lengthcCr)z :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 rrrrrrszMaxentFeatureEncodingI.labelscCr)z :return: A string describing the value of the joint-feature whose index in the generated feature vectors is ``fid``. :rtype: str rrr_rrrrVrzMaxentFeatureEncodingI.describecCr)ao 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. r)rrrrrr}rzMaxentFeatureEncodingI.trainN) rrrrr+rrrVr}rrrrrds  rc@r) #FunctionBackedMaxentFeatureEncodingz A feature encoding that calls a user-supplied function to map a given featureset/label pair to a sparse joint-feature vector. cCs||_||_||_dS)ag 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)_length_func_labels)rfuncrrrrrrs z,FunctionBackedMaxentFeatureEncoding.__init__cCs |||Sr)rrrrrr+s z*FunctionBackedMaxentFeatureEncoding.encodecCr!rrrrrrrz*FunctionBackedMaxentFeatureEncoding.lengthcCr!rrrrrrrrz*FunctionBackedMaxentFeatureEncoding.labelscCsdS)Nzno description availablerrrrrrVsz,FunctionBackedMaxentFeatureEncoding.describeN) rrrrrr+rrrVrrrrrs rc@HeZdZdZdddZddZddZd d Zd d Ze dddZ dS)BinaryMaxentFeatureEncodinga 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. Fct|ttt|krtdt|_ |_ t|_ d_ d_ |rBfddt |D_ jtj 7_|rbdd|D}fddt |D_ jt|7_dSdS)a :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. HMapping values must be exactly the set of integers from 0...len(mapping)Nci|] \}}||jqSrrr<rZr,rrr ,z8BinaryMaxentFeatureEncoding.__init__..cSh|]\}}}|qSrrr<fnamefvalr,rrr 2z7BinaryMaxentFeatureEncoding.__init__..crrrr<rZrrrrr3 setvaluesrbrr~rar_mappingr _alwayson_unseenrTrrmappingunseen_featuresalwayson_featuresfnamesrrrr0   z$BinaryMaxentFeatureEncoding.__init__cCsg}|D]<\}}|||f|jvr ||j|||fdfq|jrB|jD] }|||f|jvr2nq&||jvrB||j|dfq|jrU||jvrU||j|df|SNrH)itemsrappendrrrrr%r,rrrlabel2rrrr+6s  z"BinaryMaxentFeatureEncoding.encodecCt|ts tdz|jWn!ty/dgt|j|_|jD] \}}||j|<q#Ynw|t|jkrI|j|\}}}|d|d|S|jri||j vri|jD]\}}||krfd|SqXdS|j r||j vr|j D]\}}||krd|SqxdSt dNzdescribe() expected an intz==rDz label is %rz %s is unseenzBad feature id isinstancerSrwZ _inv_mappingAttributeErrorrrrrrrr~rr/inforZrrr,Zf_id2rrrrVQ4      z$BinaryMaxentFeatureEncoding.describecCr!rrrrrrrjz"BinaryMaxentFeatureEncoding.labelscCr!rrrrrrrnrz"BinaryMaxentFeatureEncoding.lengthrNc Ksi}t}tt}|D]@\}} |r| |vrtd| || |D]&\} } || | fd7<|| | f|krJ| | | f|vrJt||| | | f<q$q |durR|}|||fi|S)a Construct and return new feature encoding, based on a given training corpus ``train_toks``. See the class description ``BinaryMaxentFeatureEncoding`` for a description of the joint-features that will be included in this encoding. :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. :type count_cutoff: int :param count_cutoff: A cutoff value that is used to discard rare joint-features. If a joint-feature's value is 1 fewer than ``count_cutoff`` times in the training corpus, then that joint-feature is not included in the generated encoding. :type labels: list :param labels: A list of labels that should be used by the classifier. If not specified, then the set of labels attested in ``train_toks`` will be used. :param options: Extra parameters for the constructor, such as ``unseen_features`` and ``alwayson_features``. Unexpected label %srHN)rrrSr~addrr rrrrroptionsrZ seen_labelscounttokr,rrrrrr}rs"     z!BinaryMaxentFeatureEncoding.trainFFrN rrrrrr+rVrrrr}rrrrrs (1rc@s@eZdZdZ dddZeddZdd Zd d Zd d Z dS) GISEncodinga A binary feature encoding which adds one new joint-feature to the joint-features defined by ``BinaryMaxentFeatureEncoding``: a correction feature, whose value is chosen to ensure that the sparse vector always sums to a constant non-negative number. This new feature is used to ensure two preconditions for the GIS training algorithm: - At least one feature vector index must be nonzero for every token. - The feature vector must sum to a constant non-negative number for every token. FNcCs:t||||||durtdd|Dd}||_dS)a  :param C: The correction constant. The value of the correction feature is based on this value. In particular, its value is ``C - sum([v for (f,v) in encoding])``. :seealso: ``BinaryMaxentFeatureEncoding.__init__`` NcSrrrrrrrrrz'GISEncoding.__init__..rH)rrr_C)rrrrrCrrrrs   zGISEncoding.__init__cCr!)zOThe non-negative constant that all encoded feature vectors will sum to.)rrrrrrsz GISEncoding.CcCsTt|||}t|}tdd|D}||jkrtd|||j|f|S)Ncs|]\}}|VqdSrr)r<fvrrrr>z%GISEncoding.encode..z&Correction feature is not high enough!)rr+rsumrr~r)rr%r,rZ base_lengthr.rrrr+s  zGISEncoding.encodecCst|dSr)rrrrrrrr'zGISEncoding.lengthcCs$|t|kr d|jSt||S)NzCorrection feature (%s))rrrrV)rr/rrrrVs  zGISEncoding.describe)FFN) rrrrrpropertyrr+rrVrrrrrs   rc@sDeZdZdddZddZddZdd Zd d ZedddZ d S)TadmEventMaxentFeatureEncodingFcCs*t||_t|_t|||j||dSr)rr_label_mappingrr)rrrrrrrrrs  z'TadmEventMaxentFeatureEncoding.__init__cCsg}|D]<\}}||f|jvrt|j|j||f<||jvr3t|ts.t|j|j|<n||j|<||j||f|j|fq|Sr)rrrrrrSr)rr%r,rfeaturevaluerrrr+s   z%TadmEventMaxentFeatureEncoding.encodecCr!rrrrrrrrz%TadmEventMaxentFeatureEncoding.labelscCs2|jD]\}}|j||f|kr||fSqdSr)r)rr_rr,rrrrVs  z'TadmEventMaxentFeatureEncoding.describecCs t|jSr)rrrrrrrrz%TadmEventMaxentFeatureEncoding.lengthrNc Kst}|sg}t|}|D] \}}||vr||q |D]\}}|D]}|D]}||f|vr7t||||f<q'q#q|||fi|Sr)rrarr) rrrrrrrr%r,rrrrr}s"    z$TadmEventMaxentFeatureEncoding.trainrr) rrrrr+rrVrrr}rrrrrs rc@r)TypedMaxentFeatureEncodingaZ A feature encoding that generates vectors containing integer, float and binary joint-features of the form: Binary (for string and boolean features): | joint_feat(fs, l) = { 1 if (fs[fname] == fval) and (l == label) | { | { 0 otherwise Value (for integer and float features): | joint_feat(fs, l) = { fval if (fs[fname] == type(fval)) | { and (l == label) | { | { not encoded 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. For string and boolean features [type(fval) not in (int, float)] this method will create one feature for each combination of ``fname``, ``fval``, and ``label`` that occurs at least once in the training corpus. For integer and float features [type(fval) in (int, float)] this method will create one feature for each combination of ``fname`` and ``label`` that occurs at least once in the training corpus. For binary features 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. Fcr)a :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. rNcrrrrrrrr{rz7TypedMaxentFeatureEncoding.__init__..cSrrrrrrrrrz6TypedMaxentFeatureEncoding.__init__..crrrrrrrrrrrrrrrTrz#TypedMaxentFeatureEncoding.__init__cCsg}|D]]\}}t|ttfr+|t||f|jvr*||j|t||f|fq|||f|jvrA||j|||fdfq|jrc|jD] }|||f|jvrSnqG||jvrc||j|dfq|j rv||j vrv||j |df|Sr) rrrSfloattyperrrrrrrrrr+s&  z!TypedMaxentFeatureEncoding.encodecCrrrrrrrrVrz#TypedMaxentFeatureEncoding.describecCr!rrrrrrrrz!TypedMaxentFeatureEncoding.labelscCr!rrrrrrrrz!TypedMaxentFeatureEncoding.lengthrNc Ksi}t}tt}|D]L\}} |r| |vrtd| || |D]2\} } t| ttfvr4t| } || | fd7<|| | f|krV| | | f|vrVt||| | | f<q$q |dur^|}|||fi|S)a) Construct and return new feature encoding, based on a given training corpus ``train_toks``. See the class description ``TypedMaxentFeatureEncoding`` for a description of the joint-features that will be included in this encoding. Note: recognized feature values types are (int, float), over types are interpreted as regular binary features. :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. :type count_cutoff: int :param count_cutoff: A cutoff value that is used to discard rare joint-features. If a joint-feature's value is 1 fewer than ``count_cutoff`` times in the training corpus, then that joint-feature is not included in the generated encoding. :type labels: list :param labels: A list of labels that should be used by the classifier. If not specified, then the set of labels attested in ``train_toks`` will be used. :param options: Extra parameters for the constructor, such as ``unseen_features`` and ``alwayson_features``. rrHN) rrrSr~rrrrrrrrrr}s&     z TypedMaxentFeatureEncoding.trainrrrrrrrrs 81 rrocKs|ddt|}|durtj||d}t|dstdd|j}t||}tt |dkd}t t |d } |D]} t j | | <q=t|| } t |} ~|dkr\td |d|d krkttd td zU |d kr|jpxt| |} |jpt| |}|j}td|| |ft| ||}|D] } || d7<qt |}~| } | | ||7} | | || |rnqmWntytdYn|d krt| |} t| |}td| dd|d| S)a Train a new ``ConditionalExponentialClassifier``, using the given training samples, using the Generalized Iterative Scaling algorithm. 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. rpdNrrzJThe GIS algorithm requires an encoding that defines C (e.g., GISEncoding).r(rd ==> Training (%d iterations)r4- Iteration Log Likelihood Accuracy- ---------------------------------------T %9d %14.5f %9.3frH* Training stopped: keyboard interrupt Final 14.5f 9.3f) setdefaultr rr}r`rwrcalculate_empirical_fcountrnumpynonzerozerosrNINF ConditionalExponentialClassifierlog2rPllr accr itercalculate_estimated_fcountrr checkKeyboardInterrupt)rrurrr cutoffcheckerZCinvZempirical_fcount unattestedrr_ classifierZlog_empirical_fcountrriternumZestimated_fcountZlog_estimated_fcountrrrrzsj              rzcCsHt|d}|D]\}}|||D] \}}|||7<qq |SNr)rrrr+)rrfcountrr,indexvalrrrrfs  rc Csnt|d}|D]*\}}||}|D]}||}|||D]\}} |||| 7<q$qq |Sr)rrrr#rOrKr+) rrrrrr,rLrKr_rrrrrps    rc Ks|ddt|}|durtj||d}t||t|}t||}tt ||j dd}t |t|df} t t |dkd} tt|d} | D]} tj| | <qMt|| } |dkrftd |d|d kruttd td zC |d kr|jpt| |}|jpt| |}|j}td|||ft|| | |||| |}| } | |7} | | || |rnqwWntytdYn|d krt| |}t| |}td|dd|d| S)a Train a new ``ConditionalExponentialClassifier``, using the given training samples, using the Improved Iterative Scaling algorithm. 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. rprNr)r6rrHrrr4rrTrrrrrr)rr rr}rrcalculate_nfmaprarrayrN __getitem__ZreshaperrrrrrPrr rr rcalculate_deltasrr rr)rrurrrrZempirical_ffreqnfmapnfarray nftransposerrr_rrrrdeltasrrrrysh           ryc CsTt}|D]\}}|D]}|tdd|||Dq qddt|DS)a 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) csrrrr<idrrrrr>rz"calculate_nfmap..cSsi|]\}}||qSrr)r<rZnfrrrrrz#calculate_nfmap..)rrrrr+rT)rrZnfsetr_r,rrrrs   "rc Cs^d}d} t|d} tt||fd} |D]7\} } || }|D])} || | }tdd|D}|D]\}}| |||f| | |7<q:q'q| t|} t | D]P}t || }d|}||}tj|| dd}tj|| dd}|D] }||d 7<q| ||| 8} tt ||tt | }||kr| Sq\| S) a Calculate the update values for the classifier weights for this iteration of IIS. These update weights are the value of ``delta`` that solves the equation:: ffreq_empirical[i] = SUM[fs,l] (classifier.prob_classify(fs).prob(l) * feature_vector(fs,l)[i] * exp(delta[i] * nf(feature_vector(fs,l)))) Where: - *(fs,l)* is a (featureset, label) tuple from ``train_toks`` - *feature_vector(fs,l)* = ``encoding.encode(fs,l)`` - *nf(vector)* = ``sum([val for (id,val) in vector])`` This method uses Newton's method to solve this equation for *delta[i]*. In particular, it starts with a guess of ``delta[i]`` = 1; and iteratively updates ``delta`` with: | delta[i] -= (ffreq_empirical[i] - sum1[i])/(-sum2[i]) until convergence, where *sum1* and *sum2* are defined as: | sum1[i](delta) = SUM[fs,l] f[i](fs,l,delta) | sum2[i](delta) = SUM[fs,l] (f[i](fs,l,delta).nf(feature_vector(fs,l))) | f[i](fs,l,delta) = (classifier.prob_classify(fs).prob(l) . | feature_vector(fs,l)[i] . | exp(delta[i] . nf(feature_vector(fs,l)))) Note that *sum1* and *sum2* depend on ``delta``; so they need to be re-computed each iteration. The variables ``nfmap``, ``nfarray``, and ``nftranspose`` are used to generate a dense encoding for *nf(ltext)*. This allows ``_deltas`` to calculate *sum1* and *sum2* using matrices, which yields a significant performance improvement. :param train_toks: The set of training tokens. :type train_toks: list(tuple(dict, str)) :param classifier: The current classifier. :type classifier: ClassifierI :param ffreq_empirical: An array containing the empirical frequency for each feature. The *i*\ th element of this array is the empirical frequency for feature *i*. :type ffreq_empirical: sequence of float :param unattested: An array that is 1 for features that are not attested in the training data; and 0 for features that are attested. In other words, ``unattested[i]==0`` iff ``ffreq_empirical[i]==0``. :type unattested: sequence of int :param nfmap: A map that can be used to compress ``nf`` to a dense vector. :type nfmap: dict(int -> 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,rcsrrrrrrrr>Trz#calculate_deltas..r4r)ZaxisrH) rZonesrrrr#rr+rrKrbouterrB)rrrZffreq_empiricalrrrrZNEWTON_CONVERGEZ MAX_NEWTONrArr,distr-r r rZrangenumZnf_deltaZ exp_nf_deltaZnf_exp_nf_deltaZsum1Zsum2r_Zn_errorrrrrs8I     $   rc Ks"d}d}d|vr |d}d|vr|d}|dur(|dd}tj|||dd}n|dur0tdz-tjd d \} } t| d } t||| ||d Wdn1sRwYt | Wnt tfyr} ztd | | d} ~ wwg} | gd7} |r| dg7} |s| dg7} |rd|d}nd}| dd|dg7} |dkr| dg7} d|vr| dd|dg7} d|vr| ddt |dg7} t |dr| dg7} | d| g7} t | }zt| Wnt y} ztd | d!| WYd} ~ nd} ~ wwt|||}|ttj9}t||S)"a 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`` TrsrtNrrr)rrz$Specify encoding or labels, not bothznltk-prefixw)rsrtz,Error while creating megam training file: %s)z-nobiasz-repeat10z -explicitz-fvalsr(r4z-lambdaz%.2fz-tuneroz-quietrpz-maxir9ll_deltaz-dppZcostz -multilabelZ multiclasszWarning: unable to delete z: )getrr}r~tempfilemkstempopenroscloseOSErrorrBr`rremoverPrrrrer)rrurrrvrrsrtrrfdtrainfile_name trainfilerrZ inv_variancestdoutrrrrr{sl            r{c@seZdZeddZdS)r|cKs|dd}|dd}|dd}|dd}|dd}|d d}|d } |d } |s8tj|||d }tjd dd\} } tjdd\} }t| d}t||||g}|dg|d|g|rt|dd|dg| r|dd| g| r|ddt | g|d| g|d|g|dkr|dgn|dgt |t | }t |}Wdn1swYt | t ||ttj9}|||S)NrZtao_lmvmrurorrrvrrrrprqrznltk-tadm-events-z.gz)rsuffixznltk-tadm-weights-rrz-monitorz-methodz-l2z%.6fr4z-max_itz%dz-fatolz -events_inz -params_outz2>&1z-summary)rrr}rrr r rextendrBrrrrrrrr)rrrrrurrsigmarrrprZ trainfile_fdrZ weightfile_fdZweightfile_namerrZ weightfilerrrrr}sR                  zTadmMaxentClassifier.trainN)rrrrr}rrrrr|sr|c Csddl}ddlm}|}t|d}|tt|j||}Wdn1s-wYt|d }| |}Wdn1sIwYt|d }||}Wdn1sewYt|d }| |}Wdn1swY||||fS)Nr) MaxentDecoder /weights.txt /mapping.tab /labels.txt /alwayson.tab) r nltk.tabdatar$rrramapZfloat64Ztxt2listZ tupkey2dictZ tab2ivdict) tab_dirrr$Zmdecrwgtmpglabaonrrrload_maxent_paramss      r0/tmpc Cs`ddlm}ddlm}ddlm}|}||s||td|t|dd} | | t t | Wdn1sEwYt|dd} | | |Wdn1sfwYt|d d} | | |Wdn1swYt|d d} | ||WddS1swYdS) Nr)mkdir)isdir) MaxentEncoderzSaving Maxent parameters in r%rr&r'r()rr2Zos.pathr3r)r4rPrwriteZlist2txtr*reprtolistZ tupdict2tabZ ivdict2tab) r,r-r.r/r+r2r3r4Zmencrrrrsave_maxent_params2s&   "r8cCsNddlm}ddlm}|d}t|\}}}}tt|||d|}||dS)Nr)find)ClassifierBasedPOSTaggerz.taggers/maxent_treebank_pos_tagger_tab/english)r)r) nltk.datar9Znltk.tag.sequentialr:r0rr)r9r:r+r,r-r.r/Zmcrrrmaxent_pos_taggerIs   r<cCsddlm}|tj}dS)Nr) names_demo)nltk.classify.utilr=rr})r=rrrrdemoXs r?__main__)roNN)roNNr)r1)1rr ImportErrorrr collectionsrZnltk.classify.apirZnltk.classify.megamrrrZnltk.classify.tadmrrr r>r r r r;r Znltk.probabilityrZ nltk.utilr __docformat__rrrrrrrrrzrrryrrr{r|r0r8r<r?rrrrrs`-       I/K=8k b  \ \?