
    /h1                     r    S r SSKJr  SSKJr  SSKJrJrJr   " S S\5      r	S r
S r\S	:X  a  \" 5         g
g
)z
A classifier model that decides which label to assign to a token on
the basis of a tree structure, where branches correspond to conditions
on feature values, and leaves correspond to label assignments.
    )defaultdict)ClassifierI)FreqDistMLEProbDistentropyc                       \ rS rSrSS jrS rS rS rSS jrSS jr	S	 r
\      SS
 j5       r\S 5       r\S 5       r   SS jr\SS j5       r\S 5       r\ SS j5       rSrg)DecisionTreeClassifier   Nc                 4    Xl         X l        X0l        X@l        g)a  
:param label: The most likely label for tokens that reach
    this node in the decision tree.  If this decision tree
    has no children, then this label will be assigned to
    any token that reaches this decision tree.
:param feature_name: The name of the feature that this
    decision tree selects for.
:param decisions: A dictionary mapping from feature values
    for the feature identified by ``feature_name`` to
    child decision trees.
:param default: The child that will be used if the value of
    feature ``feature_name`` does not match any of the keys in
    ``decisions``.  This is used when constructing binary
    decision trees.
N)_label_fname
_decisions_default)selflabelfeature_name	decisionsdefaults        R/var/www/auris/envauris/lib/python3.13/site-packages/nltk/classify/decisiontree.py__init__DecisionTreeClassifier.__init__   s      "#    c                 J   U R                   /nU R                  b@  U R                  R                  5        H"  nUR                  UR	                  5       5        M$     U R
                  b)  UR                  U R
                  R	                  5       5        [        [        U5      5      $ N)r   r   valuesextendlabelsr   listset)r   r   dts      r   r   DecisionTreeClassifier.labels*   sr    ++??&oo,,.biik* /==$MM$--..01CK  r   c                 ,   U R                   c  U R                  $ UR                  U R                   5      nX R                  ;   a  U R                  U   R	                  U5      $ U R
                  b  U R
                  R	                  U5      $ U R                  $ r   )r   r   getr   classifyr   )r   
featuresetfvals      r   r$   DecisionTreeClassifier.classify3   sw    ;;;; ~~dkk*??"??4(11*==]]&==))*55;;r   c                 p    SnU H!  u  p4U R                  U5      U:w  d  M  US-  nM#     U[        U5      -  $ )Nr      )r$   len)r   labeled_featuresetserrorsr%   r   s        r   errorDecisionTreeClassifier.errorA   sA    !4J}}Z(E1! "5 /000r   c                     U R                   c1  U[        U5      -
  S-
  nSR                  USU-  U R                  5      $ Sn[	        [        U R                  R                  5       S S95       H  u  nu  pxU U R                    SU S3n	US-
  [        U	5      -
  nUSR                  U	SU-  UR                  5      -  nUR                   c  M_  US	:  d  Mg  XXR                  XS
-   US	-
  5      -  nM     U R                  b  U[        U5      -
  S-
  nUSR                  USU-  U R                  R                  5      -  nU R                  R                   b*  US	:  a$  XPR                  R                  XS
-   US	-
  5      -  nU$ )z
Return a string containing a pretty-printed version of this
decision tree.  Each line in this string corresponds to a
single decision tree node or leaf, and indentation is used to
display the structure of the decision tree.
   z{}{} {}
. c                 J    U S   S;   [        U S   5      R                  5       4$ Nr   )NFTstrloweritems    r   <lambda>6DecisionTreeClassifier.pretty_format.<locals>.<lambda>W   s$    $q'-@"@#d1g,BTBTBV!Wr   key=z? r)        z{}else: {} {}
)
r   r*   formatr   	enumeratesortedr   itemspretty_formatr   )
r   widthprefixdepthnsir&   resulthdrs
             r   rE   $DecisionTreeClassifier.pretty_formatH   ss    ;;F#b(A%%fcAgt{{CC!*%%'W"
A~ HT[[M4&3C
SX%A##CFMMBBA}}(UQY))%$	JJ"
 ==$F#b(A"))&#'4==;O;OPPA}}##/EAI]]00uqyQQr   c           	         U R                   c  U SU R                  < S3$ Sn[        U R                  R	                  5       S S9 Hd  u  pEX1 SU R                    SU< S3-  nUR                   b&  US	:  a   USUR                  US
-   US	-
  5      -   -  nMP  USUR                  < S3-  nMf     U R                  b  [        U R                  5      S	:X  aD  USR                  XR                   [        U R                  R                  5       5      S   5      -  nOX1 S3-  nU R                  R                   b0  US	:  a*  USU R                  R                  US
-   US	-
  5      -   -  nU$ USU R                  R                  < S3-  nU$ )z
Return a string representation of this decision tree that
expresses the decisions it makes as a nested set of pseudocode
if statements.
zreturn 
r2   c                 J    U S   S;   [        U S   5      R                  5       4$ r4   r5   r8   s    r   r:   3DecisionTreeClassifier.pseudocode.<locals>.<lambda>q   s$    d1g)<<c$q'l>P>P>RSr   r<   zif z == z: r)   r?   z{}if {} != {!r}: r   zelse: )r   r   rC   r   rD   
pseudocoder   r*   rA   r   keys)r   rG   rH   rJ   r&   rL   s         r   rS   !DecisionTreeClassifier.pseudocodef   s    ;;XWT[[O266"OO!!#S
LD 83t{{m4xr::A}}(UQYTF--ftmUQYGGGwv}}/r22
 ==$4??#q((//KKdoo.B.B.D)Ea)H  xv&&}}##/EAITDMM44Vd]EAINNN  wt}}336b99r   c                 "    U R                  5       $ r   )rE   )r   s    r   __str__DecisionTreeClassifier.__str__   s    !!##r   c           	         [        5       nU  H  u  pU H  n
UR                  U
5        M     M!     UcM  U(       aF  [        [         5      nU  H1  u  pUR                  5        H  u  pXZ   R                  U5        M     M3     U(       d  [        R                  XpU5      nO[        R                  XpXV5      nUR                  U UUS-
  UUUU5        U$ )z
:param binary: If true, then treat all feature/value pairs as
    individual binary features, rather than using a single n-way
    branch for each feature.
r)   )r   addr   rD   r	   
best_stumpbest_binary_stumprefine)r+   entropy_cutoffdepth_cutoffsupport_cutoffbinaryfeature_valuesverbosefeature_namesr%   r   fnamer&   trees                r   trainDecisionTreeClassifier.train   s      !4J#!!%( $ "5
 !f(-N%8!
#-#3#3#5KE")--d3 $6 &9
 )44GD *;;ND
 	1	
 r   c                 X    [        S U  5       5      R                  5       n[        U5      $ )Nc              3   *   #    U  H	  u  pUv   M     g 7fr    .0r%   r   s      r   	<genexpr>.DecisionTreeClassifier.leaf.<locals>.<genexpr>        N:M#6J:M   )r   maxr	   )r+   r   s     r   leafDecisionTreeClassifier.leaf   s'    N:MNNRRT%e,,r   c                 .   [        S U 5       5      R                  5       n[        [         5      nU H%  u  pBUR                  U 5      nX5   U==   S-  ss'   M'     U Vs0 s H  of[	        X6   R                  5       5      _M      nn[	        X U5      $ s  snf )Nc              3   *   #    U  H	  u  pUv   M     g 7fr   rk   rl   s      r   rn   /DecisionTreeClassifier.stump.<locals>.<genexpr>   rp   rq   r)   )r   rr   r   r#   r	   )r   r+   r   freqsr%   feature_valuevalr   s           r   stumpDecisionTreeClassifier.stump   s    N:MNNRRT H%!4J&NN<8M '1,' "5 OTTes01ABBe	T%e9EE Us   %Bc           
         [        U5      U::  a  g U R                  c  g US::  a  g U R                   H  nU V	V
s/ s H)  u  pU	R                  U R                  5      U:X  d  M&  X4PM+     nn	n
[	        S U 5       5      n[        [        U5      5      U:  d  Mg  [        R                  UUUUUUU5      U R                  U'   M     U R                  b  U V	V
s/ s H3  u  pU	R                  U R                  5      U R                  ;  d  M0  X4PM5     nn	n
[	        S U 5       5      n[        [        U5      5      U:  a!  [        R                  UUUUUUU5      U l	        g g g s  sn
n	f s  sn
n	f )Nr   c              3   *   #    U  H	  u  pUv   M     g 7fr   rk   rl   s      r   rn   0DecisionTreeClassifier.refine.<locals>.<genexpr>   s     "UDT-@j5DTrq   c              3   *   #    U  H	  u  pUv   M     g 7fr   rk   rl   s      r   rn   r      s     "XDW-@j5DWrq   )
r*   r   r   r#   r   r   r   r	   rg   r   )r   r+   r^   r_   r`   ra   rb   rc   r&   r%   r   fval_featuresetslabel_freqsdefault_featuresetss                 r   r]   DecisionTreeClassifier.refine   s}    "#~5;;1OOD ,? +>'Z>>$++.$6 $#+>    #"UDT"UUK{;/0>A(>(D(D$" "")% $$ ==$ ,?#+>'Z>>$++.dooE $#+>   #
 #"XDW"XXK{;/0>A 6 < <'" ""! B %# $#s   %E!#E!/E'
E'c                 2   [         R                  U5      nUR                  U5      nU  H4  n[         R                  XQ5      nUR                  U5      nXt:  d  M0  UnUnM6     U(       a/  [	        SR                  [        U5      UR                  U5      5        U$ )N0best stump for {:6d} toks uses {:20} err={:6.4f})r	   rs   r-   r{   printrA   r*   r   )rd   r+   rc   r[   
best_errorre   r{   stump_errors           r   r[   !DecisionTreeClassifier.best_stump  s    +001DE
%%&9:
"E*00LE++&9:K'(
"
 # BII+,j.?.?
 r   c                    [        S U 5       5      R                  5       n[        5       n[        5       nU H4  u  pcUR                  U 5      U:X  a  XC==   S-  ss'   M(  XS==   S-  ss'   M6     0 nUnUR                  5       S:  a  U[	        UR                  5       5      0nUR                  5       S:  a  [	        UR                  5       5      n[	        X0Xx5      $ )Nc              3   *   #    U  H	  u  pUv   M     g 7fr   rk   rl   s      r   rn   6DecisionTreeClassifier.binary_stump.<locals>.<genexpr>  rp   rq   r)   r   )r   rr   r#   Nr	   )	r   ry   r+   r   	pos_fdist	neg_fdistr%   r   r   s	            r   binary_stump#DecisionTreeClassifier.binary_stump  s    N:MNNRRT J	J	!4J~~l+}< A%  A% 	 "5 	;;=1&(>y}}(OPI;;=1,Y]]_=G%e9NNr   c                    [         R                  U5      nUR                  U5      nU  H@  nX&    H5  n[         R                  XgU5      nUR                  U5      n	X:  d  M1  U	nUnM7     MB     U(       ax  UR                  (       aA  SR                  UR                  [        UR                  R                  5       5      S   5      n
OSn
[        SR                  [        U5      X5      5        U$ )Nz{}={}r   z	(default)r   )r	   rs   r-   r   r   rA   r   r   rT   r   r*   )rd   r+   rb   rc   r[   r   re   r&   r{   r   descrs              r   r\   (DecisionTreeClassifier.best_binary_stump+  s     ,001DE
%%&9:
"E&-.;;!4 $kk*=>+!,J!&J . # $$%%tJ,A,A,F,F,H'I!'L $BII+,e
 r   )r   r   r   r   )NNN)F   r2      )r2   r   )g?d   
   FNF)FNF)F)__name__
__module____qualname____firstlineno__r   r   r$   r-   rE   rS   rW   staticmethodrg   rs   r{   r]   r[   r   r\   __static_attributes__rk   r   r   r	   r	      s     *!1<>$  1 1f - - 
F 
F$ 2h  " O O, DI r   r	   c                 ,    [         R                  U SSS9$ )NT)ra   rc   )r	   rg   )xs    r   fr   N  s    !''$'EEr   c                      SSK Jn Jn  U" [        U 5      n[	        UR                  SS95        [	        UR                  SS95        g )Nr   )binary_names_demo_features
names_demo   )rH   )nltk.classify.utilr   r   r   r   rE   rS   )r   r   
classifiers      r   demor   R  sC    I	%J 
*
"
"
"
+,	*

a

()r   __main__N)__doc__collectionsr   nltk.classify.apir   nltk.probabilityr   r   r   r	   r   r   r   rk   r   r   <module>r      sF    $ ) ; ;r[ rt	F* zF r   