Changeset 10208:1969fb5e8558 in orange


Ignore:
Timestamp:
02/14/12 17:01:41 (2 years ago)
Author:
Yureh Zhbontar <jure.zbontar@…>
Branch:
default
Children:
10209:1554a101960c, 10216:fddb4bc28f85
Message:

Fixed doctests in tree.py

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/classification/tree.py

    r10075 r10208  
    108108This example works with the lenses data set: 
    109109 
    110 .. 
    111     .. literalinclude:: code/treestructure.py 
    112        :lines: 7-10 
    113  
    114 >>> import Orange 
    115 >>> lenses = Orange.data.Table("lenses") 
    116 >>> tree_classifier = Orange.classification.tree.TreeLearner(lenses) 
     110    >>> import Orange 
     111    >>> lenses = Orange.data.Table("lenses") 
     112    >>> tree_classifier = Orange.classification.tree.TreeLearner(lenses) 
    117113 
    118114The following function counts the number of nodes in a tree: 
    119115 
    120 .. 
    121     .. literalinclude:: code/treestructure.py 
    122        :lines: 12-21 
    123  
    124 >>> def tree_size(node): 
    125 ...    if not node: 
    126 ...        return 0 
    127 ... 
    128 ...    size = 1 
    129 ...    if node.branch_selector: 
    130 ...        for branch in node.branches: 
    131 ...            size += tree_size(branch) 
    132 ... 
    133 ...    return size 
     116    >>> def tree_size(node): 
     117    ...    if not node: 
     118    ...        return 0 
     119    ...    size = 1 
     120    ...    if node.branch_selector: 
     121    ...        for branch in node.branches: 
     122    ...            size += tree_size(branch) 
     123    ...    return size 
    134124 
    135125If node is None, the function above return 0. Otherwise, the size is 1 
     
    146136Trees can be printed with a simple recursive function: 
    147137 
    148 .. literalinclude:: code/treestructure.py 
    149    :lines: 26-41 
     138    >>> def print_tree0(node, level): 
     139    ...     if not node: 
     140    ...         print " "*level + "<null node>" 
     141    ...         return 
     142    ...     if node.branch_selector: 
     143    ...         node_desc = node.branch_selector.class_var.name 
     144    ...         node_cont = node.distribution 
     145    ...         print "\\n" + "   "*level + "%s (%s)" % (node_desc, node_cont), 
     146    ...         for i in range(len(node.branches)): 
     147    ...             print "\\n" + "   "*level + ": %s" % node.branch_descriptions[i], 
     148    ...             print_tree0(node.branches[i], level+1) 
     149    ...     else: 
     150    ...         node_cont = node.distribution 
     151    ...         major_class = node.node_classifier.default_value 
     152    ...         print "--> %s (%s) " % (major_class, node_cont), 
    150153 
    151154The crux of the example is not in the formatting (\\n's etc.); 
     
    160163  and its ``class_var`` is the feature whose name is printed.  Class 
    161164  distributions are printed as well (they are assumed to be stored). 
    162   The :obj:`printTree0` with a level increased by 1 to increase the 
     165  The :obj:`print_tree0` with a level increased by 1 to increase the 
    163166  indent is recursively called for each branch. 
    164167* If the node is a leaf, it prints the distribution of learning instances 
     
    171174:obj:`TreeClassifier` or a :obj:`Node` can be written as follows: 
    172175 
    173     .. literalinclude:: code/treestructure.py 
    174        :lines: 43-49 
     176    >>> def print_tree(x): 
     177    ...     if isinstance(x, Orange.classification.tree.TreeClassifier): 
     178    ...         print_tree0(x.tree, 0) 
     179    ...     elif isinstance(x, Orange.classification.tree.Node): 
     180    ...         print_tree0(x, 0) 
     181    ...     else: 
     182    ...         raise TypeError, "invalid parameter" 
    175183 
    176184It's straightforward: if ``x`` is a 
    177185:obj:`TreeClassifier`, it prints ``x.tree``; if it's :obj:`Node` it 
    178186print ``x``. If it's of some other type, 
    179 an exception is raised. The output:: 
     187an exception is raised. The output: 
    180188 
    181189    >>> print_tree(tree_classifier) 
    182     tear_rate (<15.000, 5.000, 4.000>) 
    183     : reduced --> none (<12.000, 0.000, 0.000>) 
    184     : normal 
    185        astigmatic (<3.000, 5.000, 4.000>) 
    186        : no 
    187           age (<1.000, 5.000, 0.000>) 
    188           : young --> soft (<0.000, 2.000, 0.000>) 
    189           : pre-presbyopic --> soft (<0.000, 2.000, 0.000>) 
    190           : presbyopic --> none (<1.000, 1.000, 0.000>) 
    191        : yes 
    192           prescription (<2.000, 0.000, 4.000>) 
    193           : myope --> hard (<0.000, 0.000, 3.000>) 
    194           : hypermetrope --> none (<2.000, 0.000, 1.000>) 
     190    <BLANKLINE> 
     191    tear_rate (<15.000, 4.000, 5.000>)  
     192    : normal  
     193       astigmatic (<3.000, 4.000, 5.000>)  
     194       : no  
     195          age (<1.000, 0.000, 5.000>)  
     196          : pre-presbyopic --> soft (<0.000, 0.000, 2.000>)   
     197          : presbyopic  
     198             prescription (<1.000, 0.000, 1.000>)  
     199             : hypermetrope --> soft (<0.000, 0.000, 1.000>)   
     200             : myope --> none (<1.000, 0.000, 0.000>)   
     201          : young --> soft (<0.000, 0.000, 2.000>)   
     202       : yes  
     203          prescription (<2.000, 4.000, 0.000>)  
     204          : hypermetrope  
     205             age (<2.000, 1.000, 0.000>)  
     206             : pre-presbyopic --> none (<1.000, 0.000, 0.000>)   
     207             : presbyopic --> none (<1.000, 0.000, 0.000>)   
     208             : young --> hard (<0.000, 1.000, 0.000>)   
     209          : myope --> hard (<0.000, 3.000, 0.000>)   
     210    : reduced --> none (<12.000, 0.000, 0.000>)  
    195211 
    196212The tree structure examples conclude with a simple pruning function, 
     
    201217when zero, the current node will be made a leaf: 
    202218 
    203 .. literalinclude:: code/treestructure.py 
    204    :lines: 54-62 
     219    >>> def cut_tree(node, level): 
     220    ...     if node and node.branch_selector: 
     221    ...         if level: 
     222    ...             for branch in node.branches: 
     223    ...                 cut_tree(branch, level-1) 
     224    ...         else: 
     225    ...             node.branch_selector = None 
     226    ...             node.branches = None 
     227    ...             node.branch_descriptions = None 
    205228 
    206229The function acts only when :obj:`node` and :obj:`node.branch_selector` 
     
    209232descriptions. 
    210233 
    211     >>> cutTree(tree.tree, 2) 
    212     >>> printTree(tree) 
    213     tear_rate (<15.000, 5.000, 4.000>) 
    214     : reduced --> none (<12.000, 0.000, 0.000>) 
    215     : normal 
    216        astigmatic (<3.000, 5.000, 4.000>) 
    217        : no --> soft (<1.000, 5.000, 0.000>) 
    218        : yes --> hard (<2.000, 0.000, 4.000>) 
     234    >>> cut_tree(tree_classifier.tree, 2) 
     235    >>> print_tree(tree_classifier) 
     236    <BLANKLINE> 
     237    tear_rate (<15.000, 4.000, 5.000>)  
     238    : normal  
     239       astigmatic (<3.000, 4.000, 5.000>)  
     240       : no --> soft (<1.000, 0.000, 5.000>)   
     241       : yes --> hard (<2.000, 4.000, 0.000>)   
     242    : reduced --> none (<12.000, 0.000, 0.000>)  
    219243 
    220244Setting learning parameters 
     
    223247Let us construct a :obj:`TreeLearner` to play with: 
    224248 
    225 .. literalinclude:: code/treelearner.py 
    226    :lines: 7-10 
     249    >>> import Orange 
     250    >>> lenses = Orange.data.Table("lenses") 
     251    >>> learner = Orange.classification.tree.TreeLearner() 
    227252 
    228253There are three crucial components in learning: the 
     
    234259The default stopping parameters are: 
    235260 
    236     >>> print learner.stop.max_majority, learner.stop.min_instances 
     261    >>> print learner.stop.max_majority, learner.stop.min_examples 
    237262    1.0 0.0 
    238263 
     
    243268instances, the resulting tree is smaller. 
    244269 
    245     >>> learner.stop.min_instances = 5.0 
    246     >>> tree = learner(data) 
     270    >>> learner.stop.min_examples = 5.0 
     271    >>> tree = learner(lenses) 
    247272    >>> print tree 
    248273    tear_rate=reduced: none (100.00%) 
     
    255280    |    |    prescription=hypermetrope: none (66.67%) 
    256281    |    |    prescription=myope: hard (100.00%) 
     282    <BLANKLINE> 
    257283 
    258284We can also limit the maximal proportion of majority class. 
    259285 
    260286    >>> learner.stop.max_majority = 0.5 
    261     >>> tree = learner(data) 
     287    >>> tree = learner(lenses) 
    262288    >>> print tree 
    263289    none (62.50%) 
     
    13261352:obj:`C45Node` does not know to which attribute it belongs, we need to 
    13271353convert it to a string through ``classvar``, which is passed as an extra 
    1328 argument to the recursive part of printTree. 
     1354argument to the recursive part of print_tree. 
    13291355 
    13301356For discrete splits without subsetting, we print out all attribute values 
Note: See TracChangeset for help on using the changeset viewer.