source: orange/orange/Orange/classification/svm/kernels.py @ 9055:0b0ed77d8b1a

Revision 9055:0b0ed77d8b1a, 4.5 KB checked in by ales_erjavec <ales.erjavec@…>, 3 years ago (diff)

Some more doc fixes.

Line 
1import math
2
3from Orange.core import SVMLearner as _SVMLearner
4from Orange.core import KernelFunc
5
6Linear = _SVMLearner.Linear
7Polynomial = _SVMLearner.Polynomial
8RBF = _SVMLearner.RBF
9Sigmoid = _SVMLearner.Sigmoid
10Custom = _SVMLearner.Custom
11
12class KernelWrapper(object):
13   
14    """A base class for kernel function wrappers.
15   
16    :param wrapped: a function to wrap
17    :type wrapped: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`)
18   
19    """
20   
21    def __init__(self, wrapped):
22        self.wrapped=wrapped
23       
24    def __call__(self, example1, example2):
25        return self.wrapped(example1, example2)
26 
27class DualKernelWrapper(KernelWrapper):
28   
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(: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`)
35   
36    """
37   
38    def __init__(self, wrapped1, wrapped2):
39        self.wrapped1=wrapped1
40        self.wrapped2=wrapped2
41       
42class RBFKernelWrapper(KernelWrapper):
43   
44    """A Kernel wrapper that uses a wrapped kernel function in a RBF
45    (Radial Basis Function).
46   
47    :param wrapped: a function to wrap
48    :type wrapped: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`)
49    :param gamma: the gamma of the RBF
50    :type gamma: double
51   
52    """
53   
54    def __init__(self, wrapped, gamma=0.5):
55        KernelWrapper.__init__(self, wrapped)
56        self.gamma=gamma
57       
58    def __call__(self, example1, example2):
59        """:math:`exp(-gamma * wrapped(example1, example2) ^ 2)`
60       
61        """
62       
63        return math.exp(-self.gamma*math.pow(self.wrapped(example1, 
64                                                          example2),2))
65           
66class PolyKernelWrapper(KernelWrapper):
67   
68    """Polynomial kernel wrapper.
69   
70    :param wrapped: a function to wrap
71    :type wrapped: function(:class:`Orange.data.Instance`, :class:`Orange.data.Instance`)
72    :param degree: degree of the polynomial
73    :type degree: double
74   
75    """
76   
77    def __init__(self, wrapped, degree=3.0):
78        KernelWrapper.__init__(self, wrapped)
79        self.degree=degree
80       
81    def __call__(self, example1, example2):
82        """:math:`wrapped(example1, example2) ^ d`"""
83       
84        return math.pow(self.wrapped(example1, example2), self.degree)
85
86class AdditionKernelWrapper(DualKernelWrapper):
87   
88    """Addition kernel wrapper."""
89   
90    def __call__(self, example1, example2):
91        """:math:`wrapped1(example1, example2) + wrapped2(example1, example2)`
92           
93        """
94       
95        return self.wrapped1(example1, example2) + \
96                                            self.wrapped2(example1, example2)
97
98class MultiplicationKernelWrapper(DualKernelWrapper):
99   
100    """Multiplication kernel wrapper."""
101   
102    def __call__(self, example1, example2):
103        """:math:`wrapped1(example1, example2) * wrapped2(example1, example2)`
104           
105        """
106       
107        return self.wrapped1(example1, example2) * \
108                                            self.wrapped2(example1, example2)
109
110class CompositeKernelWrapper(DualKernelWrapper):
111   
112    """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`)
118    :param l: coefficient
119    :type l: double
120       
121    """
122   
123    def __init__(self, wrapped1, wrapped2, l=0.5):
124        DualKernelWrapper.__init__(self, wrapped1, wrapped2)
125        self.l=l
126       
127    def __call__(self, example1, example2):
128        """:math:`l*wrapped1(example1,example2)+(1-l)*wrapped2(example1,example2)`
129           
130        """
131        return self.l * self.wrapped1(example1, example2) + (1-self.l) * \
132                                            self.wrapped2(example1,example2)
133
134class SparseLinKernel(object):
135    def __call__(self, example1, example2):
136        """Computes a linear kernel function using the examples meta attributes
137        (need to be floats).
138       
139        """
140        s = set(example1.getmetas().keys()) & set(example2.getmetas().keys())
141        sum = 0
142        for key in s:
143            sum += float(example2[key]) * float(example1[key])
144        return sum
145
146BagOfWords = SparseLinKernel
Note: See TracBrowser for help on using the repository browser.