SampleDistribution.calculate_proportion() - Code Metrics - chen0040/pysie - Measure and Improve Code Quality continuously with Scrutinizer

SampleDistribution.calculate_proportion() B
last analyzed 2017-06-16 07:13 UTC

↳ Parent: SampleDistribution

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
dl	0
loc	14
rs	8
c	0
b	0
f	0

import math

from pysie.dsl.set import TernarySearchTrie


class Observation(object):
    x = None
    y = None
    group_id = None
    label = None

    def __init__(self, x=None, label=None, group_id=None, y=None):
        if x is not None:
            self.x = x
        if y is not None:
            self.y = y

        if label is not None:
            self.label = label

        if group_id is not None:
            self.group_id = group_id

    def is_categorical(self):
        return self.label is not None

    def is_numerical(self):
        return self.x is not None


class Sample(object):
    observations = None

    def __init__(self):
        self.observations = []

    def add(self, observation):
        self.observations.append(observation)

    def add_numeric(self, x, group_id=None):
        ob = Observation()
        ob.x = x
        ob.group_id = group_id
        self.add(ob)

    def add_category(self, label, group_id=None):
        ob = Observation()
        ob.label = label
        ob.group_id = group_id
        self.add(ob)

    def add_xy(self, x, y, group_id=None):
        ob = Observation()
        ob.x = x
        ob.y = y
        ob.group_id = group_id
        self.add(ob)

    def size(self):
        return len(self.observations)

    def get(self, index):
        return self.observations[index]

    def is_categorical(self):
        return self.observations[0].is_categorical()

    def is_numerical(self):
        return self.observations[0].is_numerical()

    def count_by_group_id(self, group_id):
        return sum(1 for x in self.observations if group_id is None or x.group_id == group_id)

    def split_by_group_id(self):
        result = TernarySearchTrie()
        for ob in self.observations:
            group_id = ob.group_id
            if group_id is None:
                continue
            if result.contains_key(group_id):
                result.get(group_id).observations.append(ob)
            else:
                sample = Sample()
                sample.observations.append(ob)
                result.put(group_id, sample)
        return result


class SampleDistribution(object):
    sample = None
    group_id = None

    categorical_value = None
    is_categorical = False
    is_numerical = False

    sd = None
    sample_size = None
    mean = None
    variance = None
    sum_of_squares = None

    proportion = None

    def __init__(self, sample=None, group_id=None, categorical_value=None, mean=None, sd=None, sample_size=None,
                 proportion=None):
        if group_id is not None:
            self.group_id = group_id

        self.track_categorical(categorical_value, proportion)
        self.track_numerical(mean, sd)

        if sample_size is not None:
            self.sample_size = sample_size

        if self.sd is not None and self.sample_size is not None:
            self.variance = self.sd * self.sd
            self.sum_of_squares = self.variance * (self.sample_size - 1)

        if sample is not None:
            self.build(sample)

    def track_categorical(self, categorical_value, proportion):
        if categorical_value is not None:
            self.categorical_value = categorical_value

        if proportion is not None:
            self.proportion = proportion
            self.is_categorical = True

    def track_numerical(self, mean, sd):
        if mean is not None:
            self.mean = mean
            self.is_numerical = True

        if sd is not None:
            self.sd = sd

    def build(self, sample):
        self.sample = sample
        if sample.is_numerical():
            self.mean = SampleDistribution.calculate_mean(sample, self.group_id)
            self.sum_of_squares = SampleDistribution.calculate_sum_of_squares(sample, self.mean, self.group_id)
            self.sample_size = sample.count_by_group_id(self.group_id)
            self.variance = self.sum_of_squares / (self.sample_size - 1)
            self.sd = math.sqrt(self.variance)
            self.is_numerical = True
        elif sample.is_categorical() and self.categorical_value is not None:
            self.proportion = SampleDistribution.calculate_proportion(sample, self.categorical_value, self.group_id)
            self.sample_size = sample.count_by_group_id(self.group_id)
            self.mean = self.proportion * self.sample_size
            self.variance = self.proportion * (1.0 - self.proportion) * self.sample_size
            self.is_categorical = True

    @staticmethod
    def calculate_mean(sample, group_id):
        count = 0
        the_sum = 0
        for i in range(sample.size()):
            observation = sample.get(i)
            if group_id is not None and observation.group_id != group_id:
                continue
            the_sum += observation.x
            count += 1
        return the_sum / count

    @staticmethod
    def calculate_sum_of_squares(sample, mean, group_id):
        the_sum = 0
        for i in range(sample.size()):
            observation = sample.get(i)
            if group_id is not None and observation.group_id != group_id:
                continue
            the_sum += (observation.x - mean) * (observation.x - mean)
        return the_sum

    @staticmethod
    def calculate_proportion(sample, categorical_value, group_id):
        counter1 = 0
        counter2 = 0
        for i in range(sample.size()):
            observation = sample.get(i)
            if group_id is not None and observation.group_id != group_id:
                continue
            counter2 += 1
            if observation.label == categorical_value:
                counter1 += 1
        if counter2 == 0:
            return 0.0
        return float(counter1) / counter2


1			import math
2
3			from pysie.dsl.set import TernarySearchTrie
4
5
6			class Observation(object):
7			x = None
8			y = None
9			group_id = None
10			label = None
11
12			def __init__(self, x=None, label=None, group_id=None, y=None):
13			if x is not None:
14			self.x = x
15			if y is not None:
16			self.y = y
17
18			if label is not None:
19			self.label = label
20
21			if group_id is not None:
22			self.group_id = group_id
23
24			def is_categorical(self):
25			return self.label is not None
26
27			def is_numerical(self):
28			return self.x is not None
29
30
31			class Sample(object):
32			observations = None
33
34			def __init__(self):
35			self.observations = []
36
37			def add(self, observation):
38			self.observations.append(observation)
39
40			def add_numeric(self, x, group_id=None):
41			ob = Observation()
42			ob.x = x
43			ob.group_id = group_id
44			self.add(ob)
45
46			def add_category(self, label, group_id=None):
47			ob = Observation()
48			ob.label = label
49			ob.group_id = group_id
50			self.add(ob)
51
52			def add_xy(self, x, y, group_id=None):
53			ob = Observation()
54			ob.x = x
55			ob.y = y
56			ob.group_id = group_id
57			self.add(ob)
58
59			def size(self):
60			return len(self.observations)
61
62			def get(self, index):
63			return self.observations[index]
64
65			def is_categorical(self):
66			return self.observations[0].is_categorical()
67
68			def is_numerical(self):
69			return self.observations[0].is_numerical()
70
71			def count_by_group_id(self, group_id):
72			return sum(1 for x in self.observations if group_id is None or x.group_id == group_id)
73
74			def split_by_group_id(self):
75			result = TernarySearchTrie()
76			for ob in self.observations:
77			group_id = ob.group_id
78			if group_id is None:
79			continue
80			if result.contains_key(group_id):
81			result.get(group_id).observations.append(ob)
82			else:
83			sample = Sample()
84			sample.observations.append(ob)
85			result.put(group_id, sample)
86			return result
87
88
89			class SampleDistribution(object):
90			sample = None
91			group_id = None
92
93			categorical_value = None
94			is_categorical = False
95			is_numerical = False
96
97			sd = None
98			sample_size = None
99			mean = None
100			variance = None
101			sum_of_squares = None
102
103			proportion = None
104
105			def __init__(self, sample=None, group_id=None, categorical_value=None, mean=None, sd=None, sample_size=None,
106			proportion=None):
107			if group_id is not None:
108			self.group_id = group_id
109
110			self.track_categorical(categorical_value, proportion)
111			self.track_numerical(mean, sd)
112
113			if sample_size is not None:
114			self.sample_size = sample_size
115
116			if self.sd is not None and self.sample_size is not None:
117			self.variance = self.sd * self.sd
118			self.sum_of_squares = self.variance * (self.sample_size - 1)
119
120			if sample is not None:
121			self.build(sample)
122
123			def track_categorical(self, categorical_value, proportion):
124			if categorical_value is not None:
125			self.categorical_value = categorical_value
126
127			if proportion is not None:
128			self.proportion = proportion
129			self.is_categorical = True
130
131			def track_numerical(self, mean, sd):
132			if mean is not None:
133			self.mean = mean
134			self.is_numerical = True
135
136			if sd is not None:
137			self.sd = sd
138
139			def build(self, sample):
140			self.sample = sample
141			if sample.is_numerical():
142			self.mean = SampleDistribution.calculate_mean(sample, self.group_id)
143			self.sum_of_squares = SampleDistribution.calculate_sum_of_squares(sample, self.mean, self.group_id)
144			self.sample_size = sample.count_by_group_id(self.group_id)
145			self.variance = self.sum_of_squares / (self.sample_size - 1)
146			self.sd = math.sqrt(self.variance)
147			self.is_numerical = True
148			elif sample.is_categorical() and self.categorical_value is not None:
149			self.proportion = SampleDistribution.calculate_proportion(sample, self.categorical_value, self.group_id)
150			self.sample_size = sample.count_by_group_id(self.group_id)
151			self.mean = self.proportion * self.sample_size
152			self.variance = self.proportion * (1.0 - self.proportion) * self.sample_size
153			self.is_categorical = True
154
155			@staticmethod
156			def calculate_mean(sample, group_id):
157			count = 0
158			the_sum = 0
159			for i in range(sample.size()):
160			observation = sample.get(i)
161			if group_id is not None and observation.group_id != group_id:
162			continue
163			the_sum += observation.x
164			count += 1
165			return the_sum / count
166
167			@staticmethod
168			def calculate_sum_of_squares(sample, mean, group_id):
169			the_sum = 0
170			for i in range(sample.size()):
171			observation = sample.get(i)
172			if group_id is not None and observation.group_id != group_id:
173			continue
174			the_sum += (observation.x - mean) * (observation.x - mean)
175			return the_sum
176
177			@staticmethod
178			def calculate_proportion(sample, categorical_value, group_id):
179			counter1 = 0
180			counter2 = 0
181			for i in range(sample.size()):
182			observation = sample.get(i)
183			if group_id is not None and observation.group_id != group_id:
184			continue
185			counter2 += 1
186			if observation.label == categorical_value:
187			counter1 += 1
188			if counter2 == 0:
189			return 0.0
190			return float(counter1) / counter2
191

chen0040 / pysie

SampleDistribution.calculate_proportion() B last analyzed 2017-06-16 07:13 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SampleDistribution.calculate_proportion() B
last analyzed 2017-06-16 07:13 UTC