示例#1
0
def get_alarm3_prob(bayes_net):
    """Calculate theprobability of the
    temperature being hot (T/F) in the
    power plant system, given that the
    alarm sounds and neither the gauge
    nor alarm is faulty."""
    # TODO: finish this function
    MA = bayes_net.get_node_by_name('main alarm')
    B = bayes_net.get_node_by_name('burglar')
    A2 = bayes_net.get_node_by_name('alarm 2')
    A3 = bayes_net.get_node_by_name('alarm 3')
    engine = JunctionTreeEngine(bayes_net)
    engine.evidence[A2] = False
    engine.evidence[MA] = False
    engine.evidence[B] = True
    Q = engine.marginal(A3)[0]
    index = Q.generate_index([True],range(Q.nDims))
    temp_prob = Q[index]

    engine2 = EnumerationEngine(bayes_net)
    engine2.evidence[A2] = False # A won against B
    engine2.evidence[MA] = False # A won against B
    engine2.evidence[B] = True # A won against B

    Q = engine.marginal(A3)[0]
    posterior = Q.table
    print "Or:" , posterior.tolist()

    return temp_prob
示例#2
0
def calculate_posterior(games_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0,0,0]
    # TODO: finish this function
    BvC_node = games_net.get_node_by_name('BvC')
    AvB_node = games_net.get_node_by_name('AvB')
    CvA_node = games_net.get_node_by_name('CvA')
    engine = EnumerationEngine(games_net)
    engine.evidence[AvB_node] = 0
    engine.evidence[CvA_node] = 2
    Q = engine.marginal(BvC_node)[0]
    posterior = Q.table
    return posterior.tolist()
示例#3
0
def calculate_posterior(games_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C.
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    # TODO: finish this function
    from Inference import EnumerationEngine
    AvB = games_net.get_node_by_name('AvB')
    BvC_node = games_net.get_node_by_name('BvC')
    CvA = games_net.get_node_by_name('CvA')
    engine = EnumerationEngine(games_net)
    engine.evidence[AvB] = 0
    engine.evidence[CvA] = 2
    Q = engine.marginal(BvC_node)[0]
    index = Q.generate_index([], range(Q.nDims))
    posterior = [Q[index][0], Q[index][1], Q[index][2]]
    return posterior
def calculate_posterior(games_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0,0,0]
    # TODO: finish this function
    from Inference import EnumerationEngine 
    AvB = games_net.get_node_by_name('AvB')
    BvC_node = games_net.get_node_by_name('BvC')
    CvA = games_net.get_node_by_name('CvA')
    engine = EnumerationEngine(games_net)
    engine.evidence[AvB] = 0
    engine.evidence[CvA] = 2
    Q = engine.marginal(BvC_node)[0]
    index = Q.generate_index([], range(Q.nDims))
    posterior = [Q[index][0], Q[index][1], Q[index][2]]
    return posterior
示例#5
0
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    # TODO: finish this function
    # raise NotImplementedError
    AvB_node = bayes_net.get_node_by_name('AvB')
    BvC_node = bayes_net.get_node_by_name('BvC')
    CvA_node = bayes_net.get_node_by_name('CvA')
    engine = EnumerationEngine(bayes_net)
    engine.evidence[AvB_node] = 0
    engine.evidence[CvA_node] = 2
    for i in range(3):
        Q = engine.marginal(BvC_node)[0]
        index = Q.generate_index([i], range(Q.nDims))
        posterior[i] = Q[index]

    return posterior  # list
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C.
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0,0,0]

    AB_node = bayes_net.get_node_by_name("AvB")
    BC_node = bayes_net.get_node_by_name("BvC")
    CA_node = bayes_net.get_node_by_name("CvA")

    engine=EnumerationEngine(bayes_net)
    engine.evidence[AB_node] = 0
    engine.evidence[CA_node] = 2
    Q = engine.marginal(BC_node)[0]
    index = Q.generate_index([], range(Q.nDims))
    B, C, tie = Q[index]
    posterior = [B, C, tie]

    return posterior
    raise NotImplementedError
def calculate_posterior(games_net):
    """Calculate the posterior distribution
    of the BvC match given that A won against
    B and tied C. Return a list of probabilities
    corresponding to win, loss and tie likelihood."""
    posterior = [0,0,0]
    # TODO: finish this function
    A_node = games_net.get_node_by_name('A')
    B_node = games_net.get_node_by_name('B')
    C_node = games_net.get_node_by_name('C')
    AvB_node = games_net.get_node_by_name('AvB')
    BvC_node = games_net.get_node_by_name('BvC')
    CvA_node = games_net.get_node_by_name('CvA')
    engine = EnumerationEngine(games_net)
    engine.evidence[AvB_node] = 0
    engine.evidence[CvA_node] = 2
    Q = engine.marginal(BvC_node)[0]
    posterior = Q.table
    return posterior
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    AvB_node = bayes_net.get_node_by_name('AvB')
    CvA_node = bayes_net.get_node_by_name('CvA')
    BvC_node = bayes_net.get_node_by_name('BvC')

    engine = EnumerationEngine(bayes_net)
    engine.evidence[AvB_node] = 0
    engine.evidence[CvA_node] = 2
    Q = engine.marginal(BvC_node)[0]

    match_results = [0, 1, 2]
    for i, result in enumerate(match_results):
        index = Q.generate_index([result], range(Q.nDims))
        posterior[i] = Q[index]

    return posterior  # list
示例#9
0
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    AvB = bayes_net.get_node_by_name("AvB")
    BvC = bayes_net.get_node_by_name("BvC")
    CvA = bayes_net.get_node_by_name("CvA")

    engine = EnumerationEngine(bayes_net)
    engine.evidence[AvB] = 0
    engine.evidence[CvA] = 2

    Q = engine.marginal(BvC)[0]
    idx1 = Q.generate_index(0, range(Q.nDims))
    idx2 = Q.generate_index(1, range(Q.nDims))
    idx3 = Q.generate_index(2, range(Q.nDims))

    posterior = [Q[idx1], Q[idx2], Q[idx3]]

    return posterior  # list
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    # TODO: finish this function
    A = bayes_net.get_node_by_name('A')
    B = bayes_net.get_node_by_name('B')
    C = bayes_net.get_node_by_name('C')
    AB = bayes_net.get_node_by_name('AvB')
    BC = bayes_net.get_node_by_name('BvC')
    CA = bayes_net.get_node_by_name('CvA')

    engine = EnumerationEngine(bayes_net)
    engine.evidence[AB] = 0
    engine.evidence[CA] = 2
    Q = engine.marginal(BC)[0]
    for val in range(3):
        index = Q.generate_index([val], range(Q.nDims))
        posterior[val] = Q[index]
    return posterior  # list
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0,0,0]
    # TODO: finish this function    
    #raise NotImplementedError
    AvB = bayes_net.get_node_by_name("AvB")
    #match_table = AvB.dist.table
    CvA=bayes_net.get_node_by_name("CvA")
    BvC=bayes_net.get_node_by_name("BvC")
    posterior_engine=EnumerationEngine(bayes_net)
    #set evidence variables. 0==win, 1==loss, 2=tie
    posterior_engine.evidence[AvB]=0
    posterior_engine.evidence[CvA]=2
    Q = posterior_engine.marginal(BvC)[0]
    win = Q.generate_index([0], range(Q.nDims))
    loss=Q.generate_index([1], range(Q.nDims))
    tie=Q.generate_index([2], range(Q.nDims))
    prob_win = Q[win]
    prob_loss=Q[loss]
    prob_tie=Q[tie]
    posterior=[prob_win,prob_loss,prob_tie]
    return posterior # list 
示例#12
0
def calculate_posterior(bayes_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    BvC_node = bayes_net.get_node_by_name('BvC')
    AvB_node = bayes_net.get_node_by_name('AvB')
    CvA_node = bayes_net.get_node_by_name('CvA')
    engine = EnumerationEngine(bayes_net)
    engine.evidence[AvB_node] = 0
    engine.evidence[CvA_node] = 2
    Q = engine.marginal(BvC_node)[0]
    index = Q.generate_index([0], range(Q.nDims))
    T1_wins = Q[index]
    index = Q.generate_index([1], range(Q.nDims))
    T2_wins = Q[index]
    index = Q.generate_index([2], range(Q.nDims))
    Tie = Q[index]

    posterior = [T1_wins, T2_wins, Tie]
    print 'calculate_posterior'
    print posterior
    sampling_question()

    return posterior  # list
def test_gibbs_convergence(games_net):
    """Calculate the posterior distribution of the EvA match given that match results = [0 0 1 1]. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""
    posterior = [0, 0, 0]
    # TODO: finish this function
    from Inference import EnumerationEngine

    AvB_node = games_net.get_node_by_name("AvB")
    BvC_node = games_net.get_node_by_name("BvC")
    CvD_node = games_net.get_node_by_name("CvD")
    DvE_node = games_net.get_node_by_name("DvE")
    EvA_node = games_net.get_node_by_name("EvA")
    engine = EnumerationEngine(games_net)
    engine.evidence[AvB_node] = 0
    engine.evidence[BvC_node] = 0
    engine.evidence[CvD_node] = 1
    engine.evidence[DvE_node] = 1
    Q = engine.marginal(EvA_node)[0]
    index = Q.generate_index([], range(Q.nDims))
    posterior = [Q[index][0], Q[index][1], Q[index][2]]
    return posterior
示例#14
0
def calculate_posterior(games_net):
    """Calculate the posterior distribution of the BvC match given that A won against B and tied C. 
    Return a list of probabilities corresponding to win, loss and tie likelihood."""

    # list of probabilities
    # Win, Loss, Tie likelihoods
    posterior = [0, 0, 0]
    engine = EnumerationEngine(games_net)
    A_node = games_net.get_node_by_name('A')
    B_node = games_net.get_node_by_name('B')
    B_node = games_net.get_node_by_name('B')
    AvB_node = games_net.get_node_by_name('AvB')
    BvC_node = games_net.get_node_by_name('BvC')
    CvA_node = games_net.get_node_by_name('CvA')

    # |AvB      the outcome of A vs. B <br> (0 = A wins, 1 = B wins, 2 = tie)|
    # |BvC      the outcome of B vs. C <br> (0 = B wins, 1 = C wins, 2 = tie)|
    # |CvA      the outcome of C vs. A <br> (0 = C wins, 1 = A wins, 2 = tie)|
    #GIVEN: A beats B
    #GIVEN: A draws with C
    #engine = EnumerationEngine(games_net)
    # A beats B
    engine.evidence[AvB_node] = [1.0, 0.0, 0.0]
    # A ties with C
    engine.evidence[CvA_node] = [0.0, 0.0, 1.0]
    # no evidence
    engine.evidence[BvC_node] = [0.0, 0.0, 0.0]
    print engine
    print BvC_node.dist.table
    #Q = engine.marginal(BvC_node)[0,0,0]
    Q = engine.marginal(BvC_node)[0]
    #AvB_distribution = ConditionalDiscreteDistribution(nodes=[A_node, B_node, AvB_node], table=dist)
    print '-' * 10
    print Q
    print enumerate(Q)
    print '-' * 10
    posterior = Q
    return posterior
def make_final_net():
    A = BayesNode(0, 2, name='A')
    B = BayesNode(1, 2, name='B')
    C = BayesNode(2, 2, name='C')
    D = BayesNode(3, 2, name='D')
    E = BayesNode(4, 2, name='E')

    A.add_child(C)
    C.add_parent(A)
    B.add_child(C)
    C.add_parent(B)
    B.add_child(D)
    D.add_parent(B)
    C.add_child(E)
    E.add_parent(C)
    D.add_child(E)
    E.add_parent(D)

    nodes = [A, B, C, D, E]
    net = BayesNet(nodes)

    A = net.get_node_by_name('A')
    B = net.get_node_by_name('B')
    C = net.get_node_by_name('C')
    D = net.get_node_by_name('D')
    E = net.get_node_by_name('E')

    A_distribution = DiscreteDistribution(A)
    index = A_distribution.generate_index([], [])
    A_distribution[index] = [0.4, 0.6]
    A.set_dist(A_distribution)

    B_distribution = DiscreteDistribution(B)
    index = B_distribution.generate_index([], [])
    B_distribution[index] = [0.8, 0.2]
    B.set_dist(B_distribution)

    print B, D
    dist = zeros([B.size(), D.size()], dtype=float32)
    dist[0, :] = [0.87, 0.13]
    dist[1, :] = [0.24, 0.76]
    D_distribution = ConditionalDiscreteDistribution(nodes=[B, D], table=dist)
    D.set_dist(D_distribution)

    dist = zeros([A.size(), B.size(), C.size()], dtype=float32)
    dist[0, 0, :] = [0.85, 0.15]
    dist[0, 1, :] = [0.68, 0.32]
    dist[1, 0, :] = [0.16, 0.84]
    dist[1, 1, :] = [0.05, 0.95]
    C_distribution = ConditionalDiscreteDistribution(nodes=[A, B, C],
                                                     table=dist)
    C.set_dist(C_distribution)

    dist = zeros([C.size(), D.size(), E.size()], dtype=float32)
    dist[0, 0, :] = [0.8, 0.2]
    dist[0, 1, :] = [0.37, 0.63]
    dist[1, 0, :] = [0.08, 0.92]
    dist[1, 1, :] = [0.07, 0.93]
    E_distribution = ConditionalDiscreteDistribution(nodes=[C, D, E],
                                                     table=dist)
    E.set_dist(E_distribution)

    engine = EnumerationEngine(net)
    #    engine1.evidence[wear] = False
    #    engine1.evidence[weap] = True
    engine.evidence[A] = True
    engine.evidence[C] = True
    Q = engine.marginal(E)[0]
    index = Q.generate_index([True], range(Q.nDims))
    prob = Q[index]
    print prob
def make_exam_net():
    H = BayesNode(0, 2, name='H')
    G = BayesNode(1, 2, name='G')
    B = BayesNode(2, 2, name='B')
    O = BayesNode(3, 2, name='O')
    D = BayesNode(4, 2, name='D')
    C = BayesNode(5, 2, name='C')

    H.add_child(B)
    B.add_parent(H)
    B.add_parent(G)
    G.add_child(B)
    G.add_child(O)
    O.add_parent(G)
    O.add_child(D)
    O.add_child(C)
    D.add_parent(O)
    C.add_parent(O)
    B.add_child(D)
    D.add_parent(B)

    nodes = [B, C, D, G, H, O]
    net = BayesNet(nodes)

    sci = BayesNode(0, 2, name='sci')
    inf = BayesNode(1, 2, name='inf')
    weap = BayesNode(2, 2, name='weap')
    car = BayesNode(3, 2, name='car')
    wear = BayesNode(4, 2, name='wear')

    sci.add_child(weap)
    weap.add_parent(sci)
    inf.add_child(weap)
    weap.add_parent(inf)
    weap.add_child(car)
    car.add_parent(weap)
    weap.add_child(wear)
    wear.add_parent(weap)

    nodes1 = [sci, weap, wear, inf, car]
    net1 = BayesNet(nodes1)

    B = net.get_node_by_name('B')
    C = net.get_node_by_name('C')
    D = net.get_node_by_name('D')
    G = net.get_node_by_name('G')
    H = net.get_node_by_name('H')
    O = net.get_node_by_name('O')

    H_distribution = DiscreteDistribution(H)
    index = H_distribution.generate_index([], [])
    H_distribution[index] = [0.6, 0.4]
    H.set_dist(H_distribution)

    G_distribution = DiscreteDistribution(G)
    index = G_distribution.generate_index([], [])
    G_distribution[index] = [0.75, 0.25]
    G.set_dist(G_distribution)

    dist = zeros([O.size(), C.size()], dtype=float32)
    dist[0, :] = [0.55, 0.45]
    dist[1, :] = [0.75, 0.25]
    C_distribution = ConditionalDiscreteDistribution(nodes=[O, C], table=dist)
    C.set_dist(C_distribution)

    dist = zeros([G.size(), O.size()], dtype=float32)
    dist[0, :] = [0.55, 0.45]
    dist[1, :] = [0.45, 0.55]
    O_distribution = ConditionalDiscreteDistribution(nodes=[G, O], table=dist)
    O.set_dist(O_distribution)

    dist = zeros([B.size(), O.size(), D.size()], dtype=float32)
    dist[0, 0, :] = [0.72, 0.28]
    dist[0, 1, :] = [0.38, 0.62]
    dist[1, 0, :] = [0.85, 0.15]
    dist[1, 1, :] = [0.65, 0.35]
    D_distribution = ConditionalDiscreteDistribution(nodes=[B, O, D],
                                                     table=dist)
    D.set_dist(D_distribution)

    dist = zeros([H.size(), G.size(), B.size()], dtype=float32)
    dist[0, 0, :] = [0.92, 0.08]
    dist[0, 1, :] = [0.75, 0.25]
    dist[1, 0, :] = [0.55, 0.45]
    dist[1, 1, :] = [0.35, 0.65]
    B_distribution = ConditionalDiscreteDistribution(nodes=[H, G, B],
                                                     table=dist)
    B.set_dist(B_distribution)

    sci = net1.get_node_by_name('sci')
    weap = net1.get_node_by_name('weap')
    wear = net1.get_node_by_name('wear')
    inf = net1.get_node_by_name('inf')
    car = net1.get_node_by_name('car')

    sci_distribution = DiscreteDistribution(sci)
    index = sci_distribution.generate_index([], [])
    sci_distribution[index] = [0.2, 0.8]
    sci.set_dist(sci_distribution)

    inf_distribution = DiscreteDistribution(inf)
    index = inf_distribution.generate_index([], [])
    inf_distribution[index] = [0.4, 0.6]
    inf.set_dist(inf_distribution)

    dist = zeros([sci.size(), inf.size(), weap.size()], dtype=float32)
    dist[0, 0, :] = [0.6, 0.4]
    dist[0, 1, :] = [0.8, 0.2]
    dist[1, 0, :] = [0.1, 0.9]
    dist[1, 1, :] = [0.3, 0.7]
    weap_distribution = ConditionalDiscreteDistribution(nodes=[sci, inf, weap],
                                                        table=dist)
    weap.set_dist(weap_distribution)

    dist = zeros([weap.size(), wear.size()], dtype=float32)
    dist[0, :] = [0.88, 0.12]
    dist[1, :] = [0.15, 0.85]
    wear_distribution = ConditionalDiscreteDistribution(nodes=[weap, wear],
                                                        table=dist)
    wear.set_dist(wear_distribution)

    dist = zeros([weap.size(), car.size()], dtype=float32)
    dist[0, :] = [0.75, 0.25]
    dist[1, :] = [0.55, 0.45]
    car_distribution = ConditionalDiscreteDistribution(nodes=[weap, car],
                                                       table=dist)
    car.set_dist(car_distribution)

    ##    engine = JunctionTreeEngine(net)
    #    engine = EnumerationEngine(net)
    ##    engine.evidence[B] = True
    #    Q = engine.marginal(C)[0]
    #    index = Q.generate_index([True], range(Q.nDims))
    #    prob = Q[index]
    #    print "Thr ptob of O = T given B = T is  ", prob

    engine1 = EnumerationEngine(net1)
    engine1.evidence[wear] = False
    engine1.evidence[weap] = True
    #   engine1.evidence[sci] = False
    Q = engine1.marginal(car)[0]
    index = Q.generate_index([True], range(Q.nDims))
    prob = Q[index]
    print prob