def __init__(self, thisData, thisEerObject, thisCllrObject, thisConfig, thisExpName, thisDebug): self._debug = thisDebug self.data = thisData self._eerObject = thisEerObject self._cllrObject = thisCllrObject self.config = thisConfig self._expName = thisExpName self._printToFilename = thisExpName self.debug = thisDebug Probability.__init__(self, self.data, self.config, self.debug) self.plotType = 'det_plot' self.fig = None self.event = None # Values required for linear scale => gaussian scale conversion at __ppndf__() self.__SPLIT__ = 0.42 self.__A0__ = 2.5066282388 self.__A1__ = -18.6150006252 self.__A2__ = 41.3911977353 self.__A3__ = -25.4410604963 self.__B1__ = -8.4735109309 self.__B2__ = 23.0833674374 self.__B3__ = -21.0622410182 self.__B4__ = 3.1308290983 self.__C0__ = -2.7871893113 self.__C1__ = -2.2979647913 self.__C2__ = 4.8501412713 self.__C3__ = 2.3212127685 self.__D1__ = 3.5438892476 self.__D2__ = 1.6370678189 self.__EPS__ = 2.2204e-16
def test_probability_class(): shoe = Shoe(8) prob = Probability(shoe) hand = Hand([c9, c4]) dealer = Hand([c6]) prob1 = prob.probability_of_hand(hand, 0) exp1 = 0.0059314179796107515 prob2 = prob.probability_of_card(c0) exp2 = 0.07692307692307693 if prob1 == exp1: print("SUCCESS: probability class return correct probability") else: print( f"FAIL: probability return '{prob1}' probability expected '{exp1}'" ) if prob2 == exp2: print("SUCCESS: probability class return correct probability") else: print( f"FAIL: probability return '{prob2}' probability expected '{exp2}'" )
def __init__(self, thisData, thisEerObject, thisCllrObject, thisConfig, thisExpName, thisDebug): self._debug = thisDebug self.data = thisData self._eerObject = thisEerObject self._cllrObject = thisCllrObject self.config = thisConfig self._expName = thisExpName self._printToFilename = thisExpName self.debug = thisDebug Probability.__init__(self, self.data, self.config, self.debug) self.plotType = 'det_plot' self.fig = None self.event = None # Values required for linear scale => gaussian scale conversion at __ppndf__() self.__SPLIT__ = 0.42 self.__A0__ = 2.5066282388 self.__A1__ = -18.6150006252 self.__A2__ = 41.3911977353 self.__A3__ = -25.4410604963 self.__B1__ = -8.4735109309 self.__B2__ = 23.0833674374 self.__B3__ = -21.0622410182 self.__B4__ = 3.1308290983 self.__C0__ = -2.7871893113 self.__C1__ = -2.2979647913 self.__C2__ = 4.8501412713 self.__C3__ = 2.3212127685 self.__D1__ = 3.5438892476 self.__D2__ = 1.6370678189 self.__EPS__ = 2.2204e-16
def ID(y, x, G, verbose=False): G._construct_observed_and_confounded() P = Probability() y = [y] if type( y ) == str else y # If I just have a single vertex, I need to wrap it in a list. x = [x] if type(x) == str else x y = set(y) x = set(x) tree = Tree() top_ord = G.get_topological_order() prettyPrint("Topological order: {:}", top_ord, depth=0, verbose=verbose) try: output = ID_internal(y, x, G, Probability(), top_ord, tree=tree, depth=0, verbose=verbose) output.P.query = {'Y': y, 'X': x} return output.P except UnidentifiableEffect as e: return e
def __init__(self, thisData, thisCllrWrapper, thisConfig, thisExpName, thisDebug=True): self.data = thisData self.cllr = thisCllrWrapper self.config = thisConfig self._printToFilename = thisExpName self._expName = thisExpName self.debug = thisDebug Probability.__init__(self, self.data, self.config, self.debug) self.plotType = 'eer_plot' self.fig = None self.event = None metaDataValues = self.data.getMetaDataValues() metaColors = self.config.getMetaColors() self.colors = assignColors2MetaDataValue(metaDataValues, metaColors) self.eerData = self.computeProbabilities(self.eerFunc) self.eerValue = {} self.score = {} for thisMetaValue in sorted(self.colors.keys()): for metaValue, PD, PP, X in self.eerData: if thisMetaValue == metaValue: try: self.eerValue[metaValue], self.score[metaValue] = self.computeEer(PD, PP, X) print("EER: {:.4f} % at score: {:.4f} and meta value: {}".format( self.eerValue[metaValue] * 100, self.score[metaValue], metaValue) ) except Exception as e: print("Problem computing EER for %s: %s" % (thisMetaValue, e)) else: self.eerValue[metaValue] *= 100 break
def fromSong(song, cut=util.CUT, p=None): p = Probability() p.addSong(song, cut) h = [] for part in song.parts: if len(part.flat) > cut: h.append(calculate(part, p)) return h
def main(): filename = sys.argv[1] if len(sys.argv) > 1 else util.FAKE_FILE song = converter.parse(filename) p = Probability() p.addSong(song) h = fromSong(song, p=p) print(h) log.info("%d parts.", len(h)) h = mean(p) print(h)
def __init__(self, thisData, thisEer, thisCllr, thisConfig, thisExpName, thisDebug=True): self.data = thisData self._eerObject = thisEer self._cllrObject = thisCllr self.config = thisConfig self._expName = thisExpName self._printToFilename = thisExpName self.debug = thisDebug self.plotType = 'roc_plot' self.fig = None self.event = None Probability.__init__(self, self.data, self.config, self.debug)
def test_changing_sample_value_will_change_total_probability(): data = [{1: TRUE, 2: FALSE, 3: TRUE}, {1: FALSE, 2: FALSE, 3: FALSE}] key = FALSE probability_service = Probability() probability_service.calculate_for_many_samples(data, key) results = probability_service.total assert results == 0.25 probability_service.probability_samples[1] = 1 assert probability_service.total == 0.5
def main(): playTournament( numOfGames=200, players=[NN(), Rotate(), BeatPrevious(), Probability(), Conditional()])
def __init__(self, thisData, thisEer, thisCllr, thisConfig, thisExpName, thisDebug=True): self.data = thisData self._eerObject = thisEer self._cllrObject = thisCllr self.config = thisConfig self._expName = thisExpName self._printToFilename = thisExpName self.debug = thisDebug self.plotType = 'roc_plot' self.fig = None self.event = None Probability.__init__(self, self.data, self.config, self.debug)
def __init__(self, thisData, thisCllrWrapper, thisConfig, thisExpName, thisDebug=True): self.data = thisData self.cllr = thisCllrWrapper self.config = thisConfig self._printToFilename = thisExpName self._expName = thisExpName self.debug = thisDebug Probability.__init__(self, self.data, self.config, self.debug) self.plotType = 'eer_plot' self.fig = None self.event = None metaDataValues = self.data.getMetaDataValues() metaColors = self.config.getMetaColors() self.colors = assignColors2MetaDataValue(metaDataValues, metaColors) self.eerData = self.computeProbabilities(self.eerFunc) self.eerValue = {} self.eerScore = {} for thisMetaValue in sorted(self.colors.keys()): for metaValue, PD, PP, X in self.eerData: if thisMetaValue == metaValue: try: self.eerValue[metaValue], self.eerScore[ metaValue] = self.computeEer(PD, PP, X) print( "EER: {:.4f} % at score: {:.4f} and meta value: {}" .format(self.eerValue[metaValue] * 100, self.eerScore[metaValue], metaValue)) except Exception as e: print("Problem computing EER for %s: %s" % (thisMetaValue, e)) else: self.eerValue[metaValue] *= 100 break
def dealer_class_test(card, exp): shoe = Shoe(8) prob = Probability(shoe) dealer = Dealer(shoe, prob) dealer.deal_card(card) probs = dealer.dealer_outcome_probs() # make sure probability isn't greated than one if round(sum(probs), 2) != 1.0: print(f"FAIL: dealer outcome probabilites < or > 1 : '{sum(probs)}'") return if exp == probs: print("\tSUCCESS: dealer outcome probabilites as expected") else: print("\tFAIL: dealer outcome probabilites NOT as expected")
def probabilityPage(): if request.method == "POST": n = int(request.form["n"]) n = 10 if n > 10 else n r = int(request.form["r"]) r = 10 if r > 10 else n p = request.form["p"] sp = p.split("/") sp = int(sp[0]) / int(sp[1]) prob = Probability(n, r, sp) return render_template("probability.html", page="probability", n=n, r=r, p=p, prob=prob) else: return render_template("probability.html", page="probability")
#!/usr/bin/env python # -*- coding: utf-8 -*- from argparse import ArgumentParser from deck import Deck from probability import Probability if __name__ == '__main__': parser = ArgumentParser() parser.add_argument('slate', help='provide a slate file') parser.add_argument('deck', help='provide a deck file') parser.add_argument('-c', '--count', help='output the count of hands', action='store_true') parser.add_argument('-p', '--precise', help='round less', action='store_true') parser.add_argument('-v', '--verbose', help='increase output verbosity', action='store_true') p = parser.parse_args() deck = Deck(file=p.deck, slate=p.slate, verbose=p.verbose) probability = Probability(count=p.count, deck=deck, precise=p.precise, slate=p.slate) probability.run()
def ID_internal(y, x, G, P, top_ord, tree, depth, verbose): try: #prettyPrint("Computing " + causalEffectStr(x,y) + " from " + str(P), depth=depth, verbose=verbose) # The following variables will be useful throughout the algorithm v = set(G.get_vertices()) n = G.get_num_nodes() ancestors = set(G.get_ancestors(y)) # Record the basic information about this call to the ID algorithm if len(P.var) == 0 and not (P.is_product or P.is_fraction): tree.call = Call(y, x, Probability(var=list(v)), G, line=None) else: tree.call = Call(y, x, P, G, line=None) # The topological order we were given may contain variables that don't exist in the subgraph we're working with. # We'll filter it to make sure it fits our subgraph. # We'll still keep the original around to sort sets we deal with throughout. new_top_ord = [v_i for v_i in top_ord[:] if v_i in v] ########## LINE 1 ########## if len(set(x)) == 0: if P.is_product or P.is_fraction: P_sumset = (v - y) | set(P.sumset) P.sumset = utilities.sort_subset_by_list(P_sumset, top_ord) else: P.var = utilities.sort_subset_by_list(y, top_ord) tree.call.line = 1 tree.root = P return IDOutput(P, tree) ########## LINE 2 ########## nonancestors = v - ancestors #prettyPrint("Nonancestors of {:}: {:}", y, nonanc, depth=depth, verbose=verbose) if len(nonancestors) > 0: #prettyPrint("LINE 2: non-ancestors are {:}", nonanc, depth=depth, verbose=verbose) G_ancestors = G.induced_subgraph(ancestors) if (P.is_product or P.is_fraction): P_sumset = (v - ancestors) | set(P.sumset) P.sumset = utilities.sort_subset_by_list(P_sumset, top_ord) else: P.var = utilities.sort_subset_by_list(ancestors, top_ord) out = ID_internal(y, x & ancestors, G_ancestors, P, top_ord, tree=Tree(), depth=depth + 1, verbose=verbose) tree.branch = [out.tree] tree.call.line = 2 tree.call.anc = ancestors #prettyPrint(out.P, depth=depth, verbose=verbose) return IDOutput(P=out.P, tree=tree) ########## LINE 3 ########## G.post_intervention = G.construct_post_intervention_subgraph(x) ancestors_avoiding_x = G.post_intervention.get_ancestors(y) w = (v - x) - ancestors_avoiding_x if len(w) > 0: #prettyPrint("LINE 3", depth=depth, verbose=verbose) w_connected = w & G.post_intervention.get_all_connected_vertices(y) if len(w_connected) < len(w): v_new = v - (w - w_connected) G = G.induced_subgraph(v_new) out = ID_internal(y, x | w_connected, G, P, top_ord, Tree(), depth=depth + 1, verbose=verbose) tree.branch = [out.tree] tree.call.line = 3 tree.call.w = w tree.call.anc_post_intervention = ancestors_avoiding_x #prettyPrint(out.P, depth=depth, verbose=verbose) return IDOutput(P=out.P, tree=tree) # I want to get all the C-components of G[V\X]. G.withoutX = G.induced_subgraph(v - x) components = G.withoutX.get_c_components() num_components = len(components) ########### LINE 4 ########## if num_components > 1: tree.call.line = 4 #prettyPrint("LINE 4", depth=depth, verbose=verbose) recursive_calls = [] for s_i in components: #prettyPrint("Executing ID_internal({:}, {:}, G, P)", s_i, v-s_i, depth=depth, verbose=verbose) recursive_calls.append( ID_internal(s_i, v - s_i, G, P, top_ord[:], Tree(), depth=depth + 1, verbose=verbose)) tree.branch = [child.tree for child in recursive_calls] sumset = v - (y | x) P = Probability(sumset=utilities.sort_subset_by_list( sumset, top_ord), is_product=True, children=[call.P for call in recursive_calls]) #prettyPrint(P, depth=depth, verbose=verbose) return IDOutput(P=P, tree=tree) ########### LINE 5 ########## # By the time we get here, we know that G[V\X] has a single C-component s = components[0] # prettyPrint("G[V\X] has only a single C-component: {{{:}}}".format(",".join(s)), depth=depth, verbose=verbose) components_G = G.get_c_components() # If G has only a single C-component, then the effect is unidentifiable. if len(components_G) == 1: #prettyPrint("LINE 5", depth=depth, verbose=verbose) raise UnidentifiableEffect(x, y, components_G[0], s) # Here we figure out which c-component of G is a superset of the c-component of G[V\X] s_prime = None for s_i in components_G: if s <= s_i: s_prime = s_i break ########### LINE 6 ########## # This is the case where S is a C-component of G itself. if len(s ^ s_prime) == 0: #prettyPrint("LINE 6", depth=depth, verbose=verbose) tree.call.line = 6 tree.call.s = s product_list = [None for _ in range(len(s))] P_prod = Probability() s = utilities.sort_subset_by_list(s, top_ord) for (i, v_i) in enumerate(s): ix = new_top_ord.index(v_i) cond_set = new_top_ord[0:ix] if P.is_product: P_prod = P.parse_joint(set([v_i]), set(cond_set), v, top_ord) else: P_prod = P.copy() P_prod.var = [v_i] P_prod.cond = cond_set product_list[len(s) - i - 1] = P_prod if len(s) > 1: P_new_sumset = set(s) - y P_new = Probability(sumset=utilities.sort_subset_by_list( P_new_sumset, top_ord), is_product=True, children=product_list) tree.root = P_new #prettyPrint(P_new, depth=depth, verbose=verbose) return IDOutput(P=P_new, tree=tree) if P_prod.is_product or P_prod.is_fraction: P_prod_sumset = set(P_prod.sumset) | (set(s) - y) P_prod.sumset = utilities.sort_subset_by_list( P_prod_sumset, top_ord) else: P_prod_var = set(P_prod.var) - (set(P_prod.sumset) | (set(s) - y)) P_prod.var = utilities.sort_subset_by_list(P_prod_var, top_ord) tree.root = P_prod_var #prettyPrint(P_prod, depth=depth, verbose=verbose) return IDOutput(P=P_prod, tree=tree) ########## LINE 7 ########## # This is the case where S is a subset of larger C-component S' tree.call.s = s tree.call.line = 7 # Note that we're going to set s <- s_prime to match the code from Tikka and Karvanen. # I think it's confusing, but I'll try it this way first. s = utilities.sort_subset_by_list(s_prime, top_ord) tree.call.s_prime = s G.s = G.induced_subgraph(s) product_list = [None for _ in range(len(s))] for (i, v_i) in enumerate(s): ix = new_top_ord.index(v_i) cond_set = new_top_ord[0:ix] P_prod = P.copy() P_prod.var = [v_i] P_prod.cond = cond_set product_list[len(s) - i - 1] = P_prod x_new = set(s) & x out = None if len(s) > 1: P_recursive = Probability(is_product=True, children=product_list) out = ID_internal(y, x_new, G.s, P_recursive, top_ord, Tree(), depth=depth + 1, verbose=verbose) else: out = ID_internal(y, x_new, G.s, product_list[0], top_ord, Tree(), depth=depth + 1, verbose=verbose) tree.branch = [out.tree] #prettyPrint(out.P, depth=depth, verbose=verbose) return IDOutput(P=out.P, tree=tree) except UnidentifiableEffect as e: raise e
from probability import Probability from repositories.answers_repository import CSVAnswersRepository from repositories.questions_repository import CSVQuestionsRepository from survey import Survey if __name__ == '__main__': questions_repository = CSVQuestionsRepository('data/questions.csv') answers_repository = CSVAnswersRepository('data/first_survey.csv') probability_service = Probability() s = Survey(questions_repository, answers_repository, probability_service) s.start()
def test_should_calculate_probability(data, key, expected): assert Probability().calculate_for_key(data, key) == expected
def test_should_calculate_probability_for_many_samples(data, key, expected): probability_service = Probability() results = probability_service.calculate_for_many_samples(data, key) assert results == expected