source: orange/orange/distance/__init__.py @ 9669:165371b04b4a

Revision 9669:165371b04b4a, 9.0 KB checked in by anze <anze.staric@…>, 2 years ago (diff)

Moved content of Orange dir to package dir

Line 
1import Orange
2
3from Orange.core import \
4     AlignmentList, \
5     DistanceMap, \
6     DistanceMapConstructor, \
7     ExampleDistConstructor, \
8     ExampleDistBySorting, \
9     ExampleDistVector, \
10     ExamplesDistance, \
11     ExamplesDistance_Normalized, \
12     ExamplesDistanceConstructor
13
14from Orange.core import ExamplesDistance_Hamming as Hamming
15from Orange.core import ExamplesDistance_DTW as DTW
16from Orange.core import ExamplesDistance_Euclidean as Euclidean
17from Orange.core import ExamplesDistance_Manhattan as Manhattan
18from Orange.core import ExamplesDistance_Maximal as Maximal
19from Orange.core import ExamplesDistance_Relief as Relief
20
21from Orange.core import ExamplesDistanceConstructor_DTW as DTWConstructor
22from Orange.core import ExamplesDistanceConstructor_Euclidean as EuclideanConstructor
23from Orange.core import ExamplesDistanceConstructor_Hamming as HammingConstructor
24from Orange.core import ExamplesDistanceConstructor_Manhattan as ManhattanConstructor
25from Orange.core import ExamplesDistanceConstructor_Maximal as MaximalConstructor
26from Orange.core import ExamplesDistanceConstructor_Relief as ReliefConstructor
27
28import statc
29import numpy
30from numpy import linalg
31
32class PearsonRConstructor(ExamplesDistanceConstructor):
33    """Constructs an instance of PearsonR. Not all the data needs to be given."""
34   
35    def __new__(cls, data=None, **argkw):
36        self = ExamplesDistanceConstructor.__new__(cls, **argkw)
37        self.__dict__.update(argkw)
38        if data:
39            return self.__call__(data)
40        else:
41            return self
42
43    def __call__(self, table):
44        indxs = [i for i, a in enumerate(table.domain.attributes) \
45                 if a.varType==Orange.data.Type.Continuous]
46        return PearsonR(domain=table.domain, indxs=indxs)
47
48class PearsonR(ExamplesDistance):
49    """
50    `Pearson correlation coefficient
51    <http://en.wikipedia.org/wiki/Pearson_product-moment\
52    _correlation_coefficient>`_
53    """
54
55    def __init__(self, **argkw):
56        self.__dict__.update(argkw)
57       
58    def __call__(self, e1, e2):
59        """
60        :param e1: data instances.
61        :param e2: data instances.
62       
63        Returns Pearson's disimilarity between e1 and e2,
64        i.e. (1-r)/2 where r is Sprearman's rank coefficient.
65        """
66        X1 = []
67        X2 = []
68        for i in self.indxs:
69            if not(e1[i].isSpecial() or e2[i].isSpecial()):
70                X1.append(float(e1[i]))
71                X2.append(float(e2[i]))
72        if not X1:
73            return 1.0
74        try:
75            return (1.0 - statc.pearsonr(X1, X2)[0]) / 2.
76        except:
77            return 1.0
78
79class SpearmanRConstructor(ExamplesDistanceConstructor):
80    """Constructs an instance of SpearmanR. Not all the data needs to be given."""
81   
82    def __new__(cls, data=None, **argkw):
83        self = ExamplesDistanceConstructor.__new__(cls, **argkw)
84        self.__dict__.update(argkw)
85        if data:
86            return self.__call__(data)
87        else:
88            return self
89
90    def __call__(self, table):
91        indxs = [i for i, a in enumerate(table.domain.attributes) \
92                 if a.varType==Orange.data.Type.Continuous]
93        return SpearmanR(domain=table.domain, indxs=indxs)
94
95class SpearmanR(ExamplesDistance): 
96
97    """`Spearman's rank correlation coefficient
98    <http://en.wikipedia.org/wiki/Spearman%27s_rank_\
99    correlation_coefficient>`_"""
100
101    def __init__(self, **argkw):
102        self.__dict__.update(argkw)
103       
104    def __call__(self, e1, e2):
105        """
106        :param e1: data instances.
107        :param e2: data instances.
108       
109        Returns Sprearman's disimilarity between e1 and e2,
110        i.e. (1-r)/2 where r is Sprearman's rank coefficient.
111        """
112        X1 = []; X2 = []
113        for i in self.indxs:
114            if not(e1[i].isSpecial() or e2[i].isSpecial()):
115                X1.append(float(e1[i]))
116                X2.append(float(e2[i]))
117        if not X1:
118            return 1.0
119        try:
120            return (1.0 - statc.spearmanr(X1, X2)[0]) / 2.
121        except:
122            return 1.0
123
124class MahalanobisConstructor(ExamplesDistanceConstructor):
125    """ Construct instance of Mahalanobis. """
126   
127    def __new__(cls, data=None, **argkw):
128        self = ExamplesDistanceConstructor.__new__(cls, **argkw)
129        self.__dict__.update(argkw)
130        if data:
131            return self.__call__(data)
132        else:
133            return self
134   
135    # Check attributtes a, b, c
136    def __call__(self, table, a=None, b=None, c=None, **argkw):
137        # Process data
138        dc = Orange.core.DomainContinuizer()
139        dc.classTreatment = Orange.core.DomainContinuizer.Ignore
140        dc.continuousTreatment = Orange.core.DomainContinuizer.NormalizeBySpan
141        dc.multinomialTreatment = Orange.core.DomainContinuizer.NValues
142       
143        newdomain = dc(table)
144        newtable = table.translate(newdomain)
145       
146        data, cls, _ = newtable.to_numpy()
147       
148        covariance_matrix = numpy.cov(data, rowvar=0, bias=1)
149        inverse_covariance_matrix = linalg.pinv(covariance_matrix, rcond=1e-10)
150       
151        return Mahalanobis(domain=newdomain, icm=inverse_covariance_matrix)
152
153class Mahalanobis(ExamplesDistance):
154    """`Mahalanobis distance
155    <http://en.wikipedia.org/wiki/Mahalanobis_distance>`_"""
156
157    def __init__(self, domain, icm, **argkw):
158        self.domain = domain
159        self.icm = icm
160        self.__dict__.update(argkw)
161       
162    def __call__(self, e1, e2):
163        """
164        :param e1: data instances.
165        :param e2: data instances.
166       
167        Returns Mahalanobis distance between e1 and e2.
168        """
169        e1 = Orange.data.Instance(self.domain, e1)
170        e2 = Orange.data.Instance(self.domain, e2)
171       
172        diff = []
173        for i in range(len(self.domain.attributes)):
174            diff.append(e1[i].value - e2[i].value) if not(e1[i].isSpecial() or e2[i].isSpecial()) else 0.0
175        diff = numpy.asmatrix(diff)
176        res = diff * self.icm * diff.transpose()
177        return res[0,0]**0.5
178   
179   
180class PearsonRAbsoluteConstructor(PearsonRConstructor):
181    """ Construct an instance of PearsonRAbsolute example distance estimator.
182    """
183    def __call__(self, data):
184        indxs = [i for i, a in enumerate(data.domain.attributes) \
185                 if a.varType==Orange.data.Type.Continuous]
186        return PearsonRAbsolute(domain=data.domain, indxs=indxs)
187   
188   
189class PearsonRAbsolute(PearsonR):
190    """ An example distance estimator using absolute value of Pearson
191    correlation coefficient.
192    """
193    def __call__(self, e1, e2):
194        """
195        Return absolute Pearson's dissimilarity between e1 and e2,
196        i.e.
197       
198        .. math:: (1 - abs(r))/2
199       
200        where r is Pearson's correlation coefficient.
201        """
202        X1 = []; X2 = []
203        for i in self.indxs:
204            if not(e1[i].isSpecial() or e2[i].isSpecial()):
205                X1.append(float(e1[i]))
206                X2.append(float(e2[i]))
207        if not X1:
208            return 1.0
209        try:
210            return (1.0 - abs(statc.pearsonr(X1, X2)[0]))
211        except:
212            return 1.0
213       
214       
215class SpearmanRAbsoluteConstructor(SpearmanRConstructor):
216    """ Construct an instance of SpearmanRAbsolute example distance estimator.
217    """
218    def __call__(self, data):
219        indxs = [i for i, a in enumerate(data.domain.attributes) \
220                 if a.varType==Orange.data.Type.Continuous]
221        return SpearmanRAbsolute(domain=data.domain, indxs=indxs)
222   
223   
224class SpearmanRAbsolute(SpearmanR):
225    def __call__(self, e1, e2):
226        """
227        Return absolute Spearman's dissimilarity between e1 and e2,
228        i.e.
229         
230        .. math:: (1 - abs(r))/2
231       
232        where r is Spearman's correlation coefficient.
233        """
234        X1 = []; X2 = []
235        for i in self.indxs:
236            if not(e1[i].isSpecial() or e2[i].isSpecial()):
237                X1.append(float(e1[i]))
238                X2.append(float(e2[i]))
239        if not X1:
240            return 1.0
241        try:
242            return (1.0 - abs(statc.spearmanr(X1, X2)[0]))
243        except:
244            return 1.0
245   
246   
247def distance_matrix(data, distance_constructor, progress_callback=None):
248    """ A helper function that computes an obj:`Orange.core.SymMatrix` of all
249    pairwise distances between instances in `data`.
250   
251    :param data: A data table
252    :type data: :obj:`Orange.data.Table`
253   
254    :param distance_constructor: An ExamplesDistance_Constructor instance.
255    :type distance_constructor: :obj:`Orange.distances.ExampleDistConstructor`
256   
257    """
258    from Orange.misc import progressBarMilestones as progress_milestones
259    matrix = Orange.core.SymMatrix(len(data))
260    dist = distance_constructor(data)
261   
262    msize = len(data)*(len(data) - 1)/2
263    milestones = progress_milestones(msize, 100)
264    count = 0
265    for i in range(len(data)):
266        for j in range(i + 1, len(data)):
267            matrix[i, j] = dist(data[i], data[j])
268           
269            if progress_callback and count in milestones:
270                progress_callback(100.0 * count / msize)
271            count += 1
272           
273    return matrix
Note: See TracBrowser for help on using the repository browser.