3 d @sdZy ddlZWnek r$YnXddlZddlZddlmZddlmZddl m Z m Z m Z ddl mZmZmZddlmZmZmZddlmZdd lmZdd lmZd ZGd d d eZeZGdddZGdddeZGdddeZ Gddde Z!Gddde Z"GdddeZ#d.ddZ$ddZ%dd Z&d/d!d"Z'd#d$Z(d%d&Z)d0d'd(Z*Gd)d*d*eZ+d+d,Z,e-d-kre,dS)1a 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 ddddgZed'd!d"ZdS)(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*||_||_||_|jt|ks&tdS)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 _logarithmiclengthlenAssertionError)selfencodingweightsZ logarithmicr4/tmp/pip-build-v9q4h5k9/nltk/nltk/classify/maxent.py__init__aszMaxentClassifier.__init__cCs |jjS)N)rlabels)rrrrrxszMaxentClassifier.labelscCs ||_|jjt|kstdS)z Set the feature weight vector for this classifier. :param new_weights: The new feature weight vector. :type new_weights: list of float N)rrrrr)rZ new_weightsrrr set_weights{szMaxentClassifier.set_weightscCs|jS)zg :return: The feature weight vector for this classifier. :rtype: list of float )r)rrrrrszMaxentClassifier.weightscCs|j|jS)N) prob_classifymax)r featuresetrrrclassifyszMaxentClassifier.classifyc Csi}x|jjD]z}|jj||}|jrZd}x"|D]\}}||j||7}q2W|||<qd}x"|D]\}}||j||9}qdW|||<qWt||jddS)Ngg?T)log normalize)rrencoderrr) rr!Z prob_dictlabelfeature_vectortotalf_idf_valprodrrrrs  zMaxentClassifier.prob_classifyc sd}dt|dd}j|tjjdd}|d|}tdj|d jd d |Dtd d |ddt|t t xt |D]\}}j j ||}|jfddddx|D]\} } jrj| | } nj| | } j j| } | jdd} | d| 7} t| dkr8| ddd} t|| |dd| f|| 7<qWqWtd d |ddt|tdj|d jfdd |Dtdj|d jfdd |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.3fT)keyreverseNz Featurecss"|]}dd|ddVqdS)z%8sz%sNr).0lrrr sz+MaxentClassifier.explain..z -cstj|dS)Nr)absr)Zfid__)rrrsz*MaxentClassifier.explain..z and label is rz (%s)/,z... z TOTAL:c3s|]}d|VqdS)z%8.3fNr)r3r4)sumsrrr5sz PROBS:c3s|]}dj|VqdS)z%8.3fN)prob)r3r4)pdistrrr5s)strrsortedsamplesr?printljustjoinrrint enumeraterr%sortrrdescribesplit) rr!columnsZ descr_widthTEMPLATErir&r'r)r*Zscoredescrr)r@rr>rexplains>      $zMaxentClassifier.explain csPtdrjd|Sttttjfdddd_jd|SdS)zW Generates the ranked list of informative features from most to least. _most_informative_featuresNcstj|S)N)r8r)fid)rrrr9sz.T)r/r0)hasattrrRrBlistrangerr)rnr)rrmost_informative_featuress   z*MaxentClassifier.most_informative_featuresallcs|jd}|dkr&fdd|D}n|dkr@fdd|D}x6|d|D]&}tj|ddjj|qNWdS) 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|qS)r)r)r3rS)rrr szCMaxentClassifier.show_most_informative_features..negcsg|]}j|dkr|qS)r)r)r3rS)rrrr[sz8.3fr<)rXrDrrrJ)rrWshowZfidsrSr)rrshow_most_informative_featuress z/MaxentClassifier.show_most_informative_featurescCsdt|jj|jjfS)Nz:)rrrr)rrrr__repr__s zMaxentClassifier.__repr__ZGISZIISZMEGAMZTADMNrc Ks|dkr d}x |D]}|dkrtd |qW|j}|dkrPt||||f|S|d krjt||||f|S|dkrt|||||f|S|dkr|} || d<|| d<|| d<|| d<tj|f| Std|dS)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``. NZiismax_itermin_ll min_lldeltamax_acc min_accdelta count_cutoffnormexplicit bernoullizUnexpected keyword arg %rZgisZmegamZtadmtracerrgaussian_prior_sigmazUnknown algorithm %s) rarbrcrdrerfrgrhri) TypeErrorlower train_maxent_classifier_with_iis train_maxent_classifier_with_gis"train_maxent_classifier_with_megamTadmMaxentClassifiertrain ValueError) cls train_toks algorithmrjrrrkcutoffsr/kwargsrrrrrs@> zMaxentClassifier.train)T)r,)rQ)rQrY)Nr`NNr)__name__ __module__ __qualname____doc__rrrrr"rrPrXr^r_Z ALGORITHMS classmethodrrrrrrrNs$   ,   rc@s8eZdZdZddZddZddZdd 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. cCs tdS)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)) N)NotImplementedError)rr!r&rrrr%{s zMaxentFeatureEncodingI.encodecCs tdS)z :return: The size of the fixed-length joint-feature vectors that are generated by this encoding. :rtype: int N)r)rrrrrszMaxentFeatureEncodingI.lengthcCs tdS)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 N)r)rrrrrszMaxentFeatureEncodingI.labelscCs tdS)z :return: A string describing the value of the joint-feature whose index in the generated feature vectors is ``fid``. :rtype: str N)r)rrSrrrrJszMaxentFeatureEncodingI.describecCs tdS)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. N)r)rtrurrrrrs zMaxentFeatureEncodingI.trainN) ryrzr{r|r%rrrJrrrrrrr~ds   r~c@s8eZdZdZddZddZddZdd Zd d Zd S) #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)rfuncrrrrrrsz,FunctionBackedMaxentFeatureEncoding.__init__cCs |j||S)N)r)rr!r&rrrr%sz*FunctionBackedMaxentFeatureEncoding.encodecCs|jS)N)r)rrrrrsz*FunctionBackedMaxentFeatureEncoding.lengthcCs|jS)N)r)rrrrrsz*FunctionBackedMaxentFeatureEncoding.labelscCsdS)Nzno description availabler)rrSrrrrJsz,FunctionBackedMaxentFeatureEncoding.describeN) ryrzr{r|rr%rrrJrrrrrs rc@sHeZdZdZdddZddZddZd 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. Fcst|jttt|kr$tdt|_|_t|_d_ d_ |rzfddt |D_ jtj 7_|rdd|D}fddt |D_ jt|7_dS)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. zHMapping values must be exactly the set of integers from 0...len(mapping)Ncsi|]\}}|j|qSr)r)r3rNr&)rrr ,sz8BinaryMaxentFeatureEncoding.__init__..cSsh|]\}}}|qSrr)r3fnamefvalr&rrr 2sz7BinaryMaxentFeatureEncoding.__init__..csi|]\}}|j|qSr)r)r3rNr)rrrr3s) setvaluesrVrrsrUr_mappingr _alwayson_unseenrH)rrmappingunseen_featuresalwayson_featuresfnamesr)rrrs    z$BinaryMaxentFeatureEncoding.__init__cCsg}x|jD]z\}}|||f|jkrB|j|j|||fdfq|jrx>|jD]}|||f|jkrPPqPW||jkr|j|j|dfqW|jr||jkr|j|j|df|S)Nr=)itemsrappendrrr)rr!r&rrrlabel2rrrr%6s  z"BinaryMaxentFeatureEncoding.encodec Cs"t|tstdy |jWnHtk rddgt|j|_x |jjD]\}}||j|<qJWYnX|t|jkr|j|\}}}|d|d|S|jr||jj krxp|jjD]\}}||krd|SqWnH|j o||j j krx0|j jD]\}}||krd|SqWnt ddS) Nzdescribe() expected an intr=z==z and label is z label is %rz %s is unseenzBad feature id) isinstancerGrl _inv_mappingAttributeErrorrrrrrrrs)rr)inforNrrr&f_id2rrrrJQs(  z$BinaryMaxentFeatureEncoding.describecCs|jS)N)r)rrrrrjsz"BinaryMaxentFeatureEncoding.labelscCs|jS)N)r)rrrrrnsz"BinaryMaxentFeatureEncoding.lengthrNc Ksi}t}tt}x|D]\}} |r8| |kr8td| |j| xX|jD]L\} } || | fd7<|| | f|krL| | | f|krLt||| | | f<qLWqW|dkr|}|||f|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``. zUnexpected label %sr=N)rrrGrsaddrr) rtrurfroptionsr seen_labelscounttokr&rrrrrrrrs   z!BinaryMaxentFeatureEncoding.train)FF)rN) ryrzr{r|rr%rJrrr}rrrrrrrs' 1rc@s>eZdZdZdddZeddZdd 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:tj||||||dkr0tdd|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__`` NcSsh|]\}}}|qSrr)r3rrr&rrrrsz'GISEncoding.__init__..r=)rrr_C)rrrrrCrrrrs zGISEncoding.__init__cCs|jS)zOThe non-negative constant that all encoded feature vectors will sum to.)r)rrrrrsz GISEncoding.CcCsTtj|||}tj|}tdd|D}||jkr.z&Correction feature is not high enough!)rr%rsumrrsr)rr!r&rZ base_lengthr(rrrr%s  zGISEncoding.encodecCstj|dS)Nr=)rr)rrrrrszGISEncoding.lengthcCs(|tj|krd|jStj||SdS)NzCorrection feature (%s))rrrrJ)rr)rrrrJs zGISEncoding.describe)FFN) ryrzr{r|rpropertyrr%rrJrrrrrs    rc@sDeZdZdddZddZddZdd Zd d ZedddZ d S)TadmEventMaxentFeatureEncodingFcCs*t||_t|_tj|||j||dS)N)rr_label_mappingrr)rrrrrrrrrs z'TadmEventMaxentFeatureEncoding.__init__cCsg}x|jD]x\}}||f|jkr8t|j|j||f<||jkrht|ts^t|j|j|<n ||j|<|j|j||f|j|fqW|S)N)rrrrrrGr)rr!r&rfeaturevaluerrrr%s   z%TadmEventMaxentFeatureEncoding.encodecCs|jS)N)r)rrrrrsz%TadmEventMaxentFeatureEncoding.labelscCs2x,|jD]"\}}|j||f|kr||fSqWdS)N)r)rrSrr&rrrrJsz'TadmEventMaxentFeatureEncoding.describecCs t|jS)N)rr)rrrrrsz%TadmEventMaxentFeatureEncoding.lengthrNc Kst}|sg}t|}x"|D]\}}||kr|j|qWxH|D]@\}}x6|D].}x(|D] }||f|krXt||||f<qXWqNWq@W|||f|S)N)rrUrr) rtrurfrrrr!r&rrrrrrs   z$TadmEventMaxentFeatureEncoding.train)FF)rN) ryrzr{rr%rrJrr}rrrrrrrs rc@sHeZdZdZdddZddZddZd d Zd d Ze dddZ dS)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. Fcst|jttt|kr$tdt|_|_t|_d_ d_ |rzfddt |D_ jtj 7_|rdd|D}fddt |D_ jt|7_dS)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. zHMapping values must be exactly the set of integers from 0...len(mapping)Ncsi|]\}}|j|qSr)r)r3rNr&)rrrr|sz7TypedMaxentFeatureEncoding.__init__..cSsh|]\}}}|qSrr)r3rrr&rrrrsz6TypedMaxentFeatureEncoding.__init__..csi|]\}}|j|qSr)r)r3rNr)rrrrs) rrrVrrsrUrrrrrrH)rrrrrrr)rrrUs    z#TypedMaxentFeatureEncoding.__init__cCsg}x|jD]\}}t|ttfrX|t||f|jkr|j|j|t||f|fq|||f|jkr|j|j|||fdfq|jrx>|jD]}|||f|jkrPqW||jkr|j|j|dfqW|j r||j kr|j|j |df|S)Nr=) rrrGfloattyperrrrr)rr!r&rrrrrrrr%s    z!TypedMaxentFeatureEncoding.encodec Cs"t|tstdy |jWnHtk rddgt|j|_x |jjD]\}}||j|<qJWYnX|t|jkr|j|\}}}|d|d|S|jr||jj krxp|jjD]\}}||krd|SqWnH|j o||j j krx0|j jD]\}}||krd|SqWnt ddS) Nzdescribe() expected an intr=z==z and label is z label is %rz %s is unseenzBad feature idr) rrGrlrrrrrrrrrs)rr)rrNrrr&rrrrrJs(  z#TypedMaxentFeatureEncoding.describecCs|jS)N)r)rrrrrsz!TypedMaxentFeatureEncoding.labelscCs|jS)N)r)rrrrrsz!TypedMaxentFeatureEncoding.lengthrNc Ksi}t}tt}x|D]\}} |r8| |kr8td| |j| xp|jD]d\} } t| ttfkrlt| } || | fd7<|| | f|krL| | | f|krLt||| | | f<qLWqW|dkr|}|||f|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``. zUnexpected label %sr=N) rrrGrsrrrrr) rtrurfrrrrrrr&rrrrrrrs"   z TypedMaxentFeatureEncoding.train)FF)rN) ryrzr{r|rr%rJrrr}rrrrrrrs7 1 rr`c Ks|jddt|}|dkr*tj||d}t|ds Training (%d iterations)r.z- Iteration Log Likelihood Accuracyz- ---------------------------------------z %9d %14.5f %9.3fr=z* Training stopped: keyboard interruptz Final z14.5fz z9.3f) setdefaultr rrrrTrlrcalculate_empirical_fcountrnumpynonzerozerosrNINF ConditionalExponentialClassifierlog2rDllr accr itercalculate_estimated_fcountrrcheckKeyboardInterrupt)rurjrrrw cutoffcheckerZCinvZempirical_fcount unattestedrrS classifierZlog_empirical_fcountrriternumZestimated_fcountZlog_estimated_fcountrrrrosb                  rocCsPtj|jd}x:|D]2\}}x(|j||D]\}}|||7<q,WqW|S)Nr)rrrr%)rurfcountrr&indexvalrrrrgs rc Csztj|jd}xd|D]\\}}|j|}xH|jD]<}|j|}x,|j||D]\}} |||| 7<qNWq2WqW|S)Nr)rrrrrCr?r%) rrurrrr&r@r?rSrrrrrqs   rcKs|jddt|}|dkr*tj||d}t||t|}t||}tjt ||j dd}tj |t|df} t tj |dkd} tjt|d} x| D]} tj| | <qWt|| } |dkrtd |d|d krttd td yx|d kr8|jp t| |}|jpt| |}|j}td |||ft|| | |||| |}| j} | |7} | j| |j| |rPqWWn*tk rtdYnYnX|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. rarN)r)r/rr=rz ==> Training (%d iterations)r.z- Iteration Log Likelihood Accuracyz- ---------------------------------------z %9d %14.5f %9.3fz* Training stopped: keyboard interruptz Final z14.5fz z9.3f)rr rrrrrcalculate_nfmaprarrayrB __getitem__ZreshaperrrrrrDrr rr rcalculate_deltasrrrr)rurjrrrwrZempirical_ffreqnfmapnfarray nftransposerrrSrrrrdeltasrrrrnsb            rncCs\t}xB|D]:\}}x0|jD]$}|jtdd|j||DqWq Wddt|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) css|]\}}|VqdS)Nr)r3idrrrrr5sz"calculate_nfmap..cSsi|]\}}||qSrr)r3rNnfrrrrsz#calculate_nfmap..)rrrrr%rH)rurZnfsetr_r&rrrrs (rcCspd}d} tj|jd} tjt||jfd} x~|D]v\} } |j| }xb|jD]V} |j| | }tdd|D}x2|D]*\}}| |||f|j | |7<qzWqRWq6W| t|} xt | D]}tj || }d|}||}tj|| dd}tj|| dd}x|D]}||d 7<qW| ||| 8} tjt ||tjt | }||kr| SqW| 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,rcss|]\}}|VqdS)Nr)r3rrrrrr5Usz#calculate_deltas..r.r)Zaxisr=) rZonesrrrrrr%rr?rVouterr8)rurrZffreq_empiricalrrrrZNEWTON_CONVERGEZ MAX_NEWTONrArr&distr'rrrZrangenumZnf_deltaZ exp_nf_deltaZnf_exp_nf_deltaZsum1Zsum2rSZn_errorrrrrs2I  .    rc Ks&d}d}d|kr|d}d|kr(|d}|dkrP|jdd}tj|||dd}n|dk r`tdyFtjd d \} } t| d } t||| ||d WdQRXtj | Wn4t tfk r} ztd | | WYdd} ~ XnXg} | dddg7} |r| dg7} |s | dg7} |r d|d}nd}| dd|dg7} |dkrJ| dg7} d|krh| dd|dg7} d|kr| ddt |dg7} t |dr| d g7} | d!| g7} t | }ytj| Wn8t k r} ztd"| d#| WYdd} ~ XnXt||j|}|tjtj9}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`` TrhriNrfr)rrz$Specify encoding or labels, not bothznltk-)prefixw)rhriz,Error while creating megam training file: %sz-nobiasz-repeat10z -explicitz-fvalsg?r.z-lambdaz%.2fz-tuner`z-quietraz-maxiz%sll_deltaz-dppZcostz -multilabelZ multiclasszWarning: unable to delete z: )getrrrrstempfilemkstempopenroscloseOSErrorr8rTrremoverDrrrrer)rurjrrrkrxrhrirffdtrainfile_name trainfilerrZ inv_variancestdoutrrrrrps^            &rpc@seZdZeddZdS)rqc Ks|jdd}|jdd}|jdd}|jdd}|jdd}|jd d}|jd } |jd } |sptj|||d }tjd dd\} } tjdd\} }t| d}t||||jg}|jdg|jd|g|r|jdd|dg| r|jdd| g| r|jddt | g|jd| g|jd|g|dkrP|jdgn |jdgt |t |}t |}WdQRXt j| t j||tjtj9}|||S)NrvZtao_lmvmrjr`rrrkrrfrarc)rznltk-tadm-events-z.gz)rsuffixznltk-tadm-weights-)rrz-monitorz-methodz-l2z%.6fr.z-max_itz%dz-fatolz -events_inz -params_outz2>&1z-summary)rrrrrrr r rextendr8rrrrrrrr)rtrurxrvrjrrsigmarfrarZ trainfile_fdrZ weightfile_fdZweightfile_namerrZ weightfilerrrrrrsL                 zTadmMaxentClassifier.trainN)ryrzr{r}rrrrrrrqsrqcCsddlm}|tj}dS)Nr) names_demo)nltk.classify.utilrrrr)rrrrrdemos r__main__)r`NN)r`NN)r`NNr).r|r ImportErrorrr collectionsrZnltk.classify.apirZnltk.classify.megamrrrZnltk.classify.tadmrrr rr r r Z nltk.datar Znltk.probabilityrZ nltk.utilrZ __docformat__rrr~rrrrrrorrrnrrrprqrryrrrr5sN      I/L=8k a  [ [=