Ignore:
Timestamp:
02/25/12 22:37:01 (2 years ago)
Author:
janezd <janez.demsar@…>
Branch:
default
Message:

Polished documentation about SVM

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/classification/svm/kernels.py

    r9671 r10369  
    1414    """A base class for kernel function wrappers. 
    1515     
    16     :param wrapped: a function to wrap 
    17     :type wrapped: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
     16    :param wrapped: a kernel function to wrap 
    1817     
    1918    """ 
     
    2221        self.wrapped=wrapped 
    2322         
    24     def __call__(self, example1, example2): 
    25         return self.wrapped(example1, example2) 
     23    def __call__(self, inst1, inst2): 
     24        return self.wrapped(inst1, inst2) 
    2625  
    2726class DualKernelWrapper(KernelWrapper): 
    2827     
    29     """A base class for kernel wrapper that wraps two other kernel functions. 
     28    """A base class for kernel wrapper that wraps two kernel functions. 
    3029     
    31     :param wrapped1:  a function to wrap 
    32     :type wrapped1: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
    33     :param wrapped2:  a function to wrap 
    34     :type wrapped2: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
     30    :param wrapped1:  first kernel function 
     31    :param wrapped2:  second kernel function 
    3532     
    3633    """ 
     
    4239class RBFKernelWrapper(KernelWrapper): 
    4340     
    44     """A Kernel wrapper that uses a wrapped kernel function in a RBF 
    45     (Radial Basis Function). 
     41    """A Kernel wrapper that wraps the given function into RBF 
    4642     
    47     :param wrapped: a function to wrap 
    48     :type wrapped: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
     43    :param wrapped: a kernel function 
    4944    :param gamma: the gamma of the RBF 
    5045    :type gamma: double 
     
    5651        self.gamma=gamma 
    5752         
    58     def __call__(self, example1, example2): 
    59         """:math:`exp(-gamma * wrapped(example1, example2) ^ 2)`  
    60          
     53    def __call__(self, inst1, inst2): 
     54        """Return :math:`exp(-gamma * wrapped(inst1, inst2) ^ 2)`  
    6155        """ 
    6256         
    63         return math.exp(-self.gamma*math.pow(self.wrapped(example1,  
    64                                                           example2),2)) 
     57        return math.exp( 
     58            -self.gamma*math.pow(self.wrapped(inst1, inst2), 2)) 
    6559             
    6660class PolyKernelWrapper(KernelWrapper): 
     
    6862    """Polynomial kernel wrapper. 
    6963     
    70     :param wrapped: a function to wrap 
    71     :type wrapped: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
     64    :param wrapped: a kernel function 
     65 
    7266    :param degree: degree of the polynomial 
    73     :type degree: double 
     67    :type degree: float 
    7468     
    7569    """ 
     
    7973        self.degree=degree 
    8074         
    81     def __call__(self, example1, example2): 
    82         """:math:`wrapped(example1, example2) ^ d`""" 
     75    def __call__(self, inst1, inst2): 
     76        """Return :math:`wrapped(inst1, inst2) ^ d`""" 
    8377         
    84         return math.pow(self.wrapped(example1, example2), self.degree) 
     78        return math.pow(self.wrapped(inst1, inst2), self.degree) 
    8579 
    8680class AdditionKernelWrapper(DualKernelWrapper): 
    8781     
    88     """Addition kernel wrapper.""" 
     82    """ 
     83    Addition kernel wrapper. 
     84 
     85    :param wrapped1:  first kernel function 
     86    :param wrapped2:  second kernel function 
     87 
     88    """ 
    8989     
    90     def __call__(self, example1, example2): 
    91         """:math:`wrapped1(example1, example2) + wrapped2(example1, example2)` 
     90    def __call__(self, inst1, inst2): 
     91        """Return :math:`wrapped1(inst1, inst2) + wrapped2(inst1, inst2)` 
    9292             
    9393        """ 
    9494         
    95         return self.wrapped1(example1, example2) + \ 
    96                                             self.wrapped2(example1, example2) 
     95        return self.wrapped1(inst1, inst2) + self.wrapped2(inst1, inst2) 
    9796 
    9897class MultiplicationKernelWrapper(DualKernelWrapper): 
    9998     
    100     """Multiplication kernel wrapper.""" 
     99    """ 
     100    Multiplication kernel wrapper. 
     101 
     102    :param wrapped1:  first kernel function 
     103    :param wrapped2:  second kernel function 
     104""" 
    101105     
    102     def __call__(self, example1, example2): 
    103         """:math:`wrapped1(example1, example2) * wrapped2(example1, example2)` 
     106    def __call__(self, inst1, inst2): 
     107        """Return :math:`wrapped1(inst1, inst2) * wrapped2(inst1, inst2)` 
    104108             
    105109        """ 
    106110         
    107         return self.wrapped1(example1, example2) * \ 
    108                                             self.wrapped2(example1, example2) 
     111        return self.wrapped1(inst1, inst2) * self.wrapped2(inst1, inst2) 
    109112 
    110113class CompositeKernelWrapper(DualKernelWrapper): 
    111114     
    112115    """Composite kernel wrapper. 
    113      
    114     :param wrapped1:  a function to wrap 
    115     :type wrapped1: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
    116     :param wrapped2:  a function to wrap 
    117     :type wrapped2: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`) 
     116 
     117    :param wrapped1:  first kernel function 
     118    :param wrapped2:  second kernel function 
    118119    :param l: coefficient 
    119120    :type l: double 
     
    125126        self.l=l 
    126127         
    127     def __call__(self, example1, example2): 
    128         """:math:`l*wrapped1(example1,example2)+(1-l)*wrapped2(example1,example2)` 
     128    def __call__(self, inst1, inst2): 
     129        """Return :math:`l*wrapped1(inst1, inst2) + (1-l)*wrapped2(inst1, inst2)` 
    129130             
    130131        """ 
    131         return self.l * self.wrapped1(example1, example2) + (1-self.l) * \ 
    132                                             self.wrapped2(example1,example2) 
     132        return self.l * self.wrapped1(inst1, inst2) + \ 
     133            (1-self.l) * self.wrapped2(inst1, inst2) 
    133134 
    134135class SparseLinKernel(object): 
    135     def __call__(self, example1, example2): 
    136         """Computes a linear kernel function using the examples meta attributes 
    137         (need to be floats). 
     136    def __call__(self, inst1, inst2): 
     137        """ 
     138        Compute a linear kernel function using the instances' meta attributes. 
     139        The meta attributes' values must be floats. 
    138140         
    139141        """ 
    140         s = set(example1.getmetas().keys()) & set(example2.getmetas().keys()) 
     142        s = set(inst1.getmetas().keys()) & set(inst2.getmetas().keys()) 
    141143        sum = 0 
    142144        for key in s: 
    143             sum += float(example2[key]) * float(example1[key]) 
     145            sum += float(inst2[key]) * float(inst1[key]) 
    144146        return sum 
    145147 
Note: See TracChangeset for help on using the changeset viewer.