Changeset 9013:a938072c9451 in orange


Ignore:
Timestamp:
09/24/11 11:33:05 (3 years ago)
Author:
miha <miha.stajdohar@…>
Branch:
default
Convert:
bec82b67b2ed45646bc930e244f70583aa3d4222
Message:

Written kernel doc.

Location:
orange/Orange/classification/svm
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/classification/svm/__init__.py

    r9011 r9013  
    7575Kernel wrappers 
    7676=============== 
     77 
     78Use kernel wrappers to build a custom kernel. All wrapper constructors take one 
     79or more Python functions (`wrapped` attribute) to wrap. The function must be a 
     80positive definite kernel, with two attributes (of type double) and return a  
     81double.   
    7782 
    7883.. autoclass:: Orange.classification.svm.kernels.KernelWrapper 
  • orange/Orange/classification/svm/kernels.py

    r8042 r9013  
    1212class KernelWrapper(object): 
    1313     
    14     """A base class for kernel function wrappers""" 
     14    """A base class for kernel function wrappers. 
     15     
     16    :param wrapped: a function to wrap 
     17    :type wrapped: function(double, double) 
     18     
     19    """ 
    1520     
    1621    def __init__(self, wrapped): 
    17         """:param wrapped: a function to wrap""" 
    1822        self.wrapped=wrapped 
    1923         
     
    2327class DualKernelWrapper(KernelWrapper): 
    2428     
    25     """A base class for kernel wrapper that wrap two other kernel functions.""" 
     29    """A base class for kernel wrapper that wraps two other kernel functions. 
     30     
     31    :param wrapped1:  a function to wrap 
     32    :type wrapped1: function(double, double) 
     33    :param wrapped2:  a function to wrap 
     34    :type wrapped2: function(double, double) 
     35     
     36    """ 
    2637     
    2738    def __init__(self, wrapped1, wrapped2): 
    28         """:param wrapped1: 
    29         :param wrapped2: 
    30          
    31         """ 
    3239        self.wrapped1=wrapped1 
    3340        self.wrapped2=wrapped2 
     
    3643     
    3744    """A Kernel wrapper that uses a wrapped kernel function in a RBF 
    38     (Radial Basis Function) 
     45    (Radial Basis Function). 
     46     
     47    :param wrapped: a function to wrap 
     48    :type wrapped: function(double, double) 
     49    :param gamma: the gamma of the RBF 
     50    :type gamma: double 
    3951     
    4052    """ 
    4153     
    4254    def __init__(self, wrapped, gamma=0.5): 
    43         """ 
    44         :param wrapped: a function to wrap 
    45         :param gamma: the gamma of the RBF 
    46          
    47         """ 
    4855        KernelWrapper.__init__(self, wrapped) 
    4956        self.gamma=gamma 
    5057         
    5158    def __call__(self, example1, example2): 
    52         """Return:   
    53          
    54         :math:`exp(-gamma * wrapped(example1, example2) ^ 2)`  
     59        """:math:`exp(-gamma * wrapped(example1, example2) ^ 2)`  
    5560         
    5661        """ 
     62         
    5763        return math.exp(-self.gamma*math.pow(self.wrapped(example1,  
    5864                                                          example2),2)) 
    5965             
    6066class PolyKernelWrapper(KernelWrapper): 
     67     
     68    """Polynomial kernel wrapper. 
     69     
     70    :param wrapped: a function to wrap 
     71    :type wrapped: function(double, double) 
     72    :param degree: degree of the polinomial 
     73    :type degree: double 
     74     
     75    """ 
     76     
    6177    def __init__(self, wrapped, degree=3.0): 
    62         """:param wrapped: a function to wrap 
    63         :param degree: degree of the polinomial 
    64          
    65         """ 
    6678        KernelWrapper.__init__(self, wrapped) 
    6779        self.degree=degree 
     80         
    6881    def __call__(self, example1, example2): 
    69         """Return: 
     82        """:math:`wrapped(example1, example2) ^ d`""" 
    7083         
    71         :math:`wrapped(example1, example2) ^ d` 
    72          
    73         """ 
    7484        return math.pow(self.wrapped(example1, example2), self.degree) 
    7585 
    7686class AdditionKernelWrapper(DualKernelWrapper): 
     87     
     88    """Addition kernel wrapper.""" 
     89     
    7790    def __call__(self, example1, example2): 
    78         """Return: 
    79          
    80         :math:`wrapped1(example1, example2) + wrapped2(example1, example2)` 
     91        """:math:`wrapped1(example1, example2) + wrapped2(example1, example2)` 
    8192             
    8293        """ 
     94         
    8395        return self.wrapped1(example1, example2) + \ 
    8496                                            self.wrapped2(example1, example2) 
    8597 
    8698class MultiplicationKernelWrapper(DualKernelWrapper): 
     99     
     100    """Multiplication kernel wrapper.""" 
     101     
    87102    def __call__(self, example1, example2): 
    88         """Return: 
    89          
    90         :math:`wrapped1(example1, example2) * wrapped2(example1, example2)` 
     103        """:math:`wrapped1(example1, example2) * wrapped2(example1, example2)` 
    91104             
    92105        """ 
     106         
    93107        return self.wrapped1(example1, example2) * \ 
    94108                                            self.wrapped2(example1, example2) 
    95109 
    96110class CompositeKernelWrapper(DualKernelWrapper): 
     111     
     112    """Composite kernel wrapper. 
     113     
     114    :param wrapped1:  a function to wrap 
     115    :type wrapped1: function(double, double) 
     116    :param wrapped2:  a function to wrap 
     117    :type wrapped2: function(double, double) 
     118    :param l: coefficient 
     119    :type l: double 
     120         
     121    """ 
     122     
    97123    def __init__(self, wrapped1, wrapped2, l=0.5): 
    98         DualKernelWrapper.__init__.__doc__ + """\ 
    99         :param l:  
    100          
    101         """ 
    102124        DualKernelWrapper.__init__(self, wrapped1, wrapped2) 
    103125        self.l=l 
    104126         
    105127    def __call__(self, example1, example2): 
    106         """Return: 
    107          
    108         :math:`l*wrapped1(example1,example2)+(1-l)*wrapped2(example1,example2)` 
     128        """:math:`l*wrapped1(example1,example2)+(1-l)*wrapped2(example1,example2)` 
    109129             
    110130        """ 
     
    115135    def __call__(self, example1, example2): 
    116136        """Computes a linear kernel function using the examples meta attributes 
    117         (need to be floats) 
     137        (need to be floats). 
    118138         
    119139        """ 
     
    131151        :math:`\sum_{i=1}^n example1_i * example2_i` 
    132152         
    133         using the examples meta attributes (need to be floats) 
     153        using the examples meta attributes (need to be floats). 
    134154         
    135155        """ 
Note: See TracChangeset for help on using the changeset viewer.