def updateProbs(self, probs: Tuple[float]): # Updates probability distribution with new cumulative probability distribution # Checks we're not passing anything that's not cumulative. sums = sum(probs) assert sums <= 1.00000005 and sums >= .99999995, "Probs must be a cumulative probability distribution." self.cmlProbs = genCmlProbs(probs)
def __init__(self, dimen: Tuple[int]): self.dimen = dimen # Caclulates the size of space self.range = 1 for N in self.dimen: self.range *= N # Generates probabilities for later measurements self.cmlProbs = genCmlProbs(genProbs(self.range))
def __init__(self, dimen: Tuple[int], K: int): ## Dimen is representation of measurement space M ## K is amount of classes to be assigned self.dimen = dimen self.probs = genProbs(K) # For testing self.cmlProbs = genCmlProbs(self.probs) self.range = K # Amount of possible measures is cardinality of M as represented by dimen self.mSpaceSize = 1 for N in dimen: self.mSpaceSize *= N self.tags = None self.genTags()
def genBiasTags(measures: Tuple[int], posteriors: Tuple[Tuple[float]]) -> Tuple[int]: # Assigns measures by posterior conditional probability distribution p(c|d) # Note, we can't use the classAssign function as it uses same class probabilities # for all measures - and thus produces overlap. Z = len(measures) tags = [] # For each measure for d in range(Z): # We find its set of class conditionals conds = posteriors[measures[d]] # We generate a cumulative probability distribution cmlConds = genCmlProbs(conds) # generate a sample tag = genSamples(1, cmlConds) # Adds sample to tags (since outputs a tuple we need to index) tags.append(tag[0]) return tuple(tags)
def updateProbs(self, probs: Tuple[float]): self.cmlProbs = genCmlProbs(probs)
def main(): #### Unit tests ####### Tests for sampling function. # Tests for distributions to be within range for i in range(1, 1000): sampSize = randint(1, 1000) spaceRang = randint(3, 1000) a = genProbs(spaceRang) b = genCmlProbs(a) c = genSamples(sampSize, b) for j in c: assert j <= (spaceRang - 1) and j >= 0 # Tests for suitable randomness so same samples aren't being generated. for _ in range(1000): sampSize = randint(2, 1000) spaceRang = randint(3, 1000) # Provides sufficient space for variety a = genProbs(spaceRang) b = genCmlProbs(a) c = genSamples(sampSize, b) z = genSamples(sampSize, b) assert c != z, c #####Tests genMeas method # Checks for measurement space to be of proper length Z = randint(2, 1000) dimen = genSpace(6) size = randint(2, 1000) generator = MeasurementGenerator(dimen) x = generator.genMeas(size) assert len(x) == size # Checks for values to actually exist in measurement space for _ in range(1, 1000): maxValue = 1 for i in dimen: maxValue *= i for j in x: assert j <= maxValue - 1, maxValue - j ###### Tests ClassAssign class # Verifies no class is assigned outside class values for _ in range(1000): dimen = genSpace(5) maxValue = 1 for i in dimen: maxValue *= i tagSize = randint(1, 100) tagAssign = ClassAssign(dimen, tagSize) for j in tagAssign.tags: assert j <= tagSize - 1, (j, tagSize - 1) # Verfies assignment funciton is of proper length. assert len(tagAssign.tags) == maxValue
def regenTags(self, probs: List[float]): # Regenerates tags given probability set. self.cmlProbs = genCmlProbs(probs) self.genTags()