Beispiel #1
0
    def inferenceByVariableElimination(bayesNet, queryVariables, evidenceDict, eliminationOrder):
        """
        Question 6: Your inference by variable elimination implementation
        This function should perform a probabilistic inference query that
        returns the factor:
        P(queryVariables | evidenceDict)
        It should perform inference by interleaving joining on a variable
        and eliminating that variable, in the order of variables according
        to eliminationOrder.  See inferenceByEnumeration for an example on
        how to use these functions.
        You need to use joinFactorsByVariable to join all of the factors 
        that contain a variable in order for the autograder to 
        recognize that you performed the correct interleaving of 
        joins and eliminates.
        If a factor that you are about to eliminate a variable from has 
        only one unconditioned variable, you should not eliminate it 
        and instead just discard the factor.  This is since the 
        result of the eliminate would be 1 (you marginalize 
        all of the unconditioned variables), but it is not a 
        valid factor.  So this simplifies using the result of eliminate.
        The sum of the probabilities should sum to one (so that it is a true 
        conditional probability, conditioned on the evidence).
        bayesNet:         The Bayes Net on which we are making a query.
        queryVariables:   A list of the variables which are unconditioned
                          in the inference query.
        evidenceDict:     An assignment dict {variable : value} for the
                          variables which are presented as evidence
                          (conditioned) in the inference query. 
        eliminationOrder: The order to eliminate the variables in.
        Hint: BayesNet.getAllCPTsWithEvidence will return all the Conditional 
        Probability Tables even if an empty dict (or None) is passed in for 
        evidenceDict. In this case it will not specialize any variable domains 
        in the CPTs.
        Useful functions:
        BayesNet.getAllCPTsWithEvidence
        normalize
        eliminate
        joinFactorsByVariable
        joinFactors
        """

        # this is for autograding -- don't modify
        joinFactorsByVariable = joinFactorsByVariableWithCallTracking(callTrackingList)
        eliminate             = eliminateWithCallTracking(callTrackingList)
        if eliminationOrder is None: # set an arbitrary elimination order if None given
            eliminationVariables = bayesNet.variablesSet() - set(queryVariables) -\
                                   set(evidenceDict.keys())
            eliminationOrder = sorted(list(eliminationVariables))

        "*** YOUR CODE HERE ***"
        # grab all factors where we know the evidence variables (to reduce the size of the tables)
        currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)
        # join all factors by variable
        for joinVariable in eliminationOrder:
            currentFactorsList, joinedFactor = joinFactorsByVariable(currentFactorsList, joinVariable)
            if len(joinedFactor.unconditionedVariables()) > 1:
                eliminateFactor = eliminate(joinedFactor, joinVariable)
                currentFactorsList.append(eliminateFactor)
        fullJoint = joinFactors(currentFactorsList)
        return normalize(fullJoint)
Beispiel #2
0
def inferenceByEnumeration(bayesNet, queryVariables, evidenceDict):
    """
    An inference by enumeration implementation provided as reference.
    This function performs a probabilistic inference query that
    returns the factor:

    P(queryVariables | evidenceDict)

    bayesNet:       The Bayes Net on which we are making a query.
    queryVariables: A list of the variables which are unconditioned in
                    the inference query.
    evidenceDict:   An assignment dict {variable : value} for the
                    variables which are presented as evidence
                    (conditioned) in the inference query.
    """
    callTrackingList = []
    joinFactorsByVariable = joinFactorsByVariableWithCallTracking(
        callTrackingList)
    eliminate = eliminateWithCallTracking(callTrackingList)

    # initialize return variables and the variables to eliminate
    evidenceVariablesSet = set(evidenceDict.keys())
    queryVariablesSet = set(queryVariables)
    eliminationVariables = (bayesNet.variablesSet() -
                            evidenceVariablesSet) - queryVariablesSet

    # grab all factors where we know the evidence variables (to reduce the size of the tables)
    currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)

    # join all factors by variable
    for joinVariable in bayesNet.variablesSet():
        currentFactorsList, joinedFactor = joinFactorsByVariable(
            currentFactorsList, joinVariable)
        currentFactorsList.append(joinedFactor)

    # currentFactorsList should contain the connected components of the graph now as factors, must join the connected components
    fullJoint = joinFactors(currentFactorsList)

    # marginalize all variables that aren't query or evidence
    incrementallyMarginalizedJoint = fullJoint
    for eliminationVariable in eliminationVariables:
        incrementallyMarginalizedJoint = eliminate(
            incrementallyMarginalizedJoint, eliminationVariable)

    fullJointOverQueryAndEvidence = incrementallyMarginalizedJoint

    # normalize so that the probability sums to one
    # the input factor contains only the query variables and the evidence variables,
    # both as unconditioned variables
    queryConditionedOnEvidence = normalize(fullJointOverQueryAndEvidence)
    # now the factor is conditioned on the evidence variables

    # the order is join on all variables, then eliminate on all elimination variables
    #print "callTrackingList: ", callTrackingList
    return queryConditionedOnEvidence
def inferenceByEnumeration(bayesNet, queryVariables, evidenceDict):
    """
    An inference by enumeration implementation provided as reference.
    This function performs a probabilistic inference query that
    returns the factor:

    P(queryVariables | evidenceDict)

    bayesNet:       The Bayes Net on which we are making a query.
    queryVariables: A list of the variables which are unconditioned in
                    the inference query.
    evidenceDict:   An assignment dict {variable : value} for the
                    variables which are presented as evidence
                    (conditioned) in the inference query. 
    """
    callTrackingList = []
    joinFactorsByVariable = joinFactorsByVariableWithCallTracking(callTrackingList)
    eliminate = eliminateWithCallTracking(callTrackingList)

    # initialize return variables and the variables to eliminate
    evidenceVariablesSet = set(evidenceDict.keys())
    queryVariablesSet = set(queryVariables)
    eliminationVariables = (bayesNet.variablesSet() - evidenceVariablesSet) - queryVariablesSet

    # grab all factors where we know the evidence variables (to reduce the size of the tables)
    currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)

    # join all factors by variable
    for joinVariable in bayesNet.variablesSet():
        currentFactorsList, joinedFactor = joinFactorsByVariable(currentFactorsList, joinVariable)
        currentFactorsList.append(joinedFactor)

    # currentFactorsList should contain the connected components of the graph now as factors, must join the connected components
    fullJoint = joinFactors(currentFactorsList)

    # marginalize all variables that aren't query or evidence
    incrementallyMarginalizedJoint = fullJoint
    for eliminationVariable in eliminationVariables:
        incrementallyMarginalizedJoint = eliminate(incrementallyMarginalizedJoint, eliminationVariable)

    fullJointOverQueryAndEvidence = incrementallyMarginalizedJoint

    # normalize so that the probability sums to one
    # the input factor contains only the query variables and the evidence variables, 
    # both as unconditioned variables
    queryConditionedOnEvidence = normalize(fullJointOverQueryAndEvidence)
    # now the factor is conditioned on the evidence variables

    # the order is join on all variables, then eliminate on all elimination variables
    #print "callTrackingList: ", callTrackingList
    return queryConditionedOnEvidence
Beispiel #4
0
    def inferenceByVariableElimination(bayesNet, queryVariables, evidenceDict,
                                       eliminationOrder):
        """
        Question 6: Your inference by variable elimination implementation

        This function should perform a probabilistic inference query that
        returns the factor:

        P(queryVariables | evidenceDict)

        It should perform inference by interleaving joining on a variable
        and eliminating that variable, in the order of variables according
        to eliminationOrder.  See inferenceByEnumeration for an example on
        how to use these functions.

        You need to use joinFactorsByVariable to join all of the factors
        that contain a variable in order for the autograder to
        recognize that you performed the correct interleaving of
        joins and eliminates.

        If a factor that you are about to eliminate a variable from has
        only one unconditioned variable, you should not eliminate it
        and instead just discard the factor.  This is since the
        result of the eliminate would be 1 (you marginalize
        all of the unconditioned variables), but it is not a
        valid factor.  So this simplifies using the result of eliminate.

        The sum of the probabilities should sum to one (so that it is a true
        conditional probability, conditioned on the evidence).

        bayesNet:         The Bayes Net on which we are making a query.
        queryVariables:   A list of the variables which are unconditioned
                          in the inference query.
        evidenceDict:     An assignment dict {variable : value} for the
                          variables which are presented as evidence
                          (conditioned) in the inference query.
        eliminationOrder: The order to eliminate the variables in.

        Hint: BayesNet.getAllCPTsWithEvidence will return all the Conditional
        Probability Tables even if an empty dict (or None) is passed in for
        evidenceDict. In this case it will not specialize any variable domains
        in the CPTs.

        Useful functions:
        BayesNet.getAllCPTsWithEvidence
        normalize
        eliminate
        joinFactorsByVariable
        joinFactors
        """

        # this is for autograding -- don't modify
        joinFactorsByVariable = joinFactorsByVariableWithCallTracking(
            callTrackingList)
        eliminate = eliminateWithCallTracking(callTrackingList)
        if eliminationOrder is None:  # set an arbitrary elimination order if None given
            eliminationVariables = bayesNet.variablesSet() - set(queryVariables) -\
                                   set(evidenceDict.keys())
            eliminationOrder = sorted(list(eliminationVariables))

        "*** YOUR CODE HERE ***"
        evidenceVariablesSet = set(evidenceDict.keys())
        queryVariablesSet = set(queryVariables)
        eliminationVariables = (bayesNet.variablesSet() -
                                evidenceVariablesSet) - queryVariablesSet

        # grab all factors where we know the evidence variables (to reduce the size of the tables)
        newfactor = None
        currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)
        for var in eliminationOrder:
            currentFactorsList, newfactor = joinFactorsByVariable(
                currentFactorsList, var)
            if len(newfactor.unconditionedVariables()) == 1:
                pass
            else:
                newfactor = eliminate(newfactor, var)
                currentFactorsList.append(newfactor)
        retfactor = joinFactors(currentFactorsList)
        retfactor = normalize(retfactor)
        return retfactor
Beispiel #5
0
    def inferenceByVariableElimination(bayesNet, queryVariables, evidenceDict,
                                       eliminationOrder):
        """
        Question 6: Your inference by variable elimination implementation

        This function should perform a probabilistic inference query that
        returns the factor:

        P(queryVariables | evidenceDict)

        It should perform inference by interleaving joining on a variable
        and eliminating that variable, in the order of variables according
        to eliminationOrder.  See inferenceByEnumeration for an example on
        how to use these functions.

        You need to use joinFactorsByVariable to join all of the factors 
        that contain a variable in order for the autograder to 
        recognize that you performed the correct interleaving of 
        joins and eliminates.

        If a factor that you are about to eliminate a variable from has 
        only one unconditioned variable, you should not eliminate it 
        and instead just discard the factor.  This is since the 
        result of the eliminate would be 1 (you marginalize 
        all of the unconditioned variables), but it is not a 
        valid factor.  So this simplifies using the result of eliminate.

        The sum of the probabilities should sum to one (so that it is a true 
        conditional probability, conditioned on the evidence).

        bayesNet:         The Bayes Net on which we are making a query.
        queryVariables:   A list of the variables which are unconditioned
                          in the inference query.
        evidenceDict:     An assignment dict {variable : value} for the
                          variables which are presented as evidence
                          (conditioned) in the inference query. 
        eliminationOrder: The order to eliminate the variables in.

        Hint: BayesNet.getAllCPTsWithEvidence will return all the Conditional 
        Probability Tables even if an empty dict (or None) is passed in for 
        evidenceDict. In this case it will not specialize any variable domains 
        in the CPTs.

        Useful functions:
        BayesNet.getAllCPTsWithEvidence
        normalize
        eliminate
        joinFactorsByVariable
        joinFactors


        Query: ['D']
        eliminateOrder: ['T']
        evidenceDict : W   {'W': 'sun'}
        Variables: D, W, T
        Edges: W -> D, W -> T

        cpt [Factor(set(['D']), set(['W']), {'D': ['dry', 'wet'], 'W': ['sun'], 
            'T': ['hot', 'cold']}), Factor(set(['W']), set([]), 
            {'D': ['dry', 'wet'], 'W': ['sun'], 'T': ['hot', 'cold']}),
             Factor(set(['T']), set(['W']), {'D': ['dry', 'wet'], 
                'W': ['sun'], 'T': ['hot', 'cold']})]

        join -> eliminate -> join -> eliminate
        ###
        """

        # this is for autograding -- don't modify
        joinFactorsByVariable = joinFactorsByVariableWithCallTracking(
            callTrackingList)
        eliminate = eliminateWithCallTracking(callTrackingList)
        if eliminationOrder is None:  # set an arbitrary elimination order if None given
            eliminationVariables = bayesNet.variablesSet() - set(queryVariables) -\
                                   set(evidenceDict.keys())
            eliminationOrder = sorted(list(eliminationVariables))

        "*** YOUR CODE HERE ***"
        cpts = bayesNet.getAllCPTsWithEvidence(evidenceDict)
        for join in eliminationOrder:
            cpts, joinedFactor = joinFactorsByVariable(cpts, join)
            if (len(joinedFactor.unconditionedVariables()) == 1):
                continue
            else:
                #eliminate
                eliminateVariable = join
                eliminatedFactor = eliminate(joinedFactor, eliminateVariable)
                cpts.append(eliminatedFactor)
        factor = joinFactors(cpts)
        normalizeFactor = normalize(factor)
        return normalizeFactor
Beispiel #6
0
    def inferenceByVariableElimination(bayesNet, queryVariables, evidenceDict, eliminationOrder):
        """
        Question 4: Your inference by variable elimination implementation

        This function should perform a probabilistic inference query that
        returns the factor:

        P(queryVariables | evidenceDict)

        It should perform inference by interleaving joining on a variable
        and eliminating that variable, in the order of variables according
        to eliminationOrder.  See inferenceByEnumeration for an example on
        how to use these functions.

        You need to use joinFactorsByVariable to join all of the factors 
        that contain a variable in order for the autograder to 
        recognize that you performed the correct interleaving of 
        joins and eliminates.

        If a factor that you are about to eliminate a variable from has 
        only one unconditioned variable, you should not eliminate it 
        and instead just discard the factor.  This is since the 
        result of the eliminate would be 1 (you marginalize 
        all of the unconditioned variables), but it is not a 
        valid factor.  So this simplifies using the result of eliminate.

        The sum of the probabilities should sum to one (so that it is a true 
        conditional probability, conditioned on the evidence).

        bayesNet:         The Bayes Net on which we are making a query.
        queryVariables:   A list of the variables which are unconditioned
                          in the inference query.
        evidenceDict:     An assignment dict {variable : value} for the
                          variables which are presented as evidence
                          (conditioned) in the inference query. 
        eliminationOrder: The order to eliminate the variables in.

        Hint: BayesNet.getAllCPTsWithEvidence will return all the Conditional 
        Probability Tables even if an empty dict (or None) is passed in for 
        evidenceDict. In this case it will not specialize any variable domains 
        in the CPTs.

        Useful functions:
        BayesNet.getAllCPTsWithEvidence
        normalize
        eliminate
        joinFactorsByVariable
        joinFactors
        """

        # this is for autograding -- don't modify
        joinFactorsByVariable = joinFactorsByVariableWithCallTracking(callTrackingList)
        eliminate             = eliminateWithCallTracking(callTrackingList)
        if eliminationOrder is None: # set an arbitrary elimination order if None given
            eliminationVariables = bayesNet.variablesSet() - set(queryVariables) -\
                                   set(evidenceDict.keys())
            eliminationOrder = sorted(list(eliminationVariables))

        "*** YOUR CODE HERE ***"
        evidenceVariablesSet = set(evidenceDict.keys())
        queryVariablesSet = set(queryVariables)
        eliminationVariables = set(eliminationOrder)
        
        currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)

        for i in range(len(eliminationOrder)):
            '''eviDict = {eliminationOrder[i]:evidenceDict[eliminationOrder[i]]}
            currentFactorsList = bayesNet.getAllCPTsWithEvidence(eviDict)'''
            # join factors by variable
            joinVariable = eliminationOrder[i]
            currentFactorsList, joinedFactor = joinFactorsByVariable(currentFactorsList, joinVariable)
            
        
            # marginalize the variable
            if joinedFactor.unconditionedVariables() != set(joinVariable):
                joinedFactor = eliminate(joinedFactor, joinVariable)
                currentFactorsList.append(joinedFactor)
            
    
        # currentFactorsList should contain the connected components of the graph now as factors, must join the connected components
        fullJointOverQueryAndEvidence = joinFactors(currentFactorsList)
        
        queryConditionedOnEvidence = normalize(fullJointOverQueryAndEvidence)
        return queryConditionedOnEvidence

        'pdb.set_trace()'
        util.raiseNotDefined()
Beispiel #7
0
    def inferenceByVariableElimination(bayesNet, queryVariables, evidenceDict,
                                       eliminationOrder):
        """
        Question 6: Your inference by variable elimination implementation

        This function should perform a probabilistic inference query that
        returns the factor:

        P(queryVariables | evidenceDict)

        It should perform inference by interleaving joining on a variable
        and eliminating that variable, in the order of variables according
        to eliminationOrder.  See inferenceByEnumeration for an example on
        how to use these functions.

        You need to use joinFactorsByVariable to join all of the factors
        that contain a variable in order for the autograder to
        recognize that you performed the correct interleaving of
        joins and eliminates.

        If a factor that you are about to eliminate a variable from has
        only one unconditioned variable, you should not eliminate it
        and instead just discard the factor.  This is since the
        result of the eliminate would be 1 (you marginalize
        all of the unconditioned variables), but it is not a
        valid factor.  So this simplifies using the result of eliminate.

        The sum of the probabilities should sum to one (so that it is a true
        conditional probability, conditioned on the evidence).

        bayesNet:         The Bayes Net on which we are making a query.
        queryVariables:   A list of the variables which are unconditioned
                          in the inference query.
        evidenceDict:     An assignment dict {variable : value} for the
                          variables which are presented as evidence
                          (conditioned) in the inference query.
        eliminationOrder: The order to eliminate the variables in.

        Hint: BayesNet.getAllCPTsWithEvidence will return all the Conditional
        Probability Tables even if an empty dict (or None) is passed in for
        evidenceDict. In this case it will not specialize any variable domains
        in the CPTs.

        Useful functions:
        BayesNet.getAllCPTsWithEvidence
        normalize
        eliminate
        joinFactorsByVariable
        joinFactors
        """

        # this is for autograding -- don't modify
        joinFactorsByVariable = joinFactorsByVariableWithCallTracking(
            callTrackingList)
        eliminate = eliminateWithCallTracking(callTrackingList)
        if eliminationOrder is None:  # set an arbitrary elimination order if None given
            eliminationVariables = bayesNet.variablesSet() - set(queryVariables) -\
                                   set(evidenceDict.keys())
            eliminationOrder = sorted(list(eliminationVariables))

        "*** YOUR CODE HERE ***"
        #util.raiseNotDefined()
        """
        # print "@@@@@queryVariables ", queryVariables
        # print "@@@@@evidenceDict ", evidenceDict
        # print "@@@@@eliminationOrder ", eliminationOrder
        # print "@@@@@bayesNet ", bayesNet
        # currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)
        currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)
        # print "@@@@@currentFactorsList ", currentFactorsList
        for joinVariable in eliminationOrder:
            # print "@@@@@joinVariable ", joinVariable
            currentFactorsList, joinedFactor = joinFactorsByVariable(currentFactorsList, joinVariable)
            # print "@@@@@currentFactorsList ", currentFactorsList
            # print "@@@@@joinedFactor ", joinedFactor
            if len(joinedFactor.unconditionedVariables()) > 1:
                eliminatedFactor = eliminate(joinedFactor, joinVariable)
                currentFactorsList.append(eliminatedFactor)
        # print "@@@@@currentFactorsList ", currentFactorsList
        joinedFactor = joinFactors(currentFactorsList)
        normalizedFactor = normalize(joinedFactor)
        return normalizedFactor
        """

        # grab all factors where we know the evidence variables (to reduce the size of the tables)
        # pass by evidenceDict through BayesNet.getAllCPTsWithEvidence
        factors = bayesNet.getAllCPTsWithEvidence(evidenceDict)

        # join all factors by eliminationOrder
        for join_Factor in eliminationOrder:
            not_joined_Factor, joined = joinFactorsByVariable(
                factors, join_Factor)
            factors = not_joined_Factor
            # currentFactorsList should contain the connected components of the graph now as factors, must join the connected components
            joined_unconditioned = joined.unconditionedVariables()
            if len(joined_unconditioned) > 1:
                temp_factor = eliminate(joined, join_Factor)  # eliminate
                not_joined_Factor.append(temp_factor)
        joinedFactors = joinFactors(not_joined_Factor)
        return normalize(joinedFactors)  # normalize the joinedFactors
    def inferenceByVariableElimination(bayesNet, queryVariables, evidenceDict,
                                       eliminationOrder):
        """
        Question 6: Your inference by variable elimination implementation

        This function should perform a probabilistic inference query that
        returns the factor:

        P(queryVariables | evidenceDict)

        It should perform inference by interleaving joining on a variable
        and eliminating that variable, in the order of variables according
        to eliminationOrder.  See inferenceByEnumeration for an example on
        how to use these functions.

        You need to use joinFactorsByVariable to join all of the factors 
        that contain a variable in order for the autograder to 
        recognize that you performed the correct interleaving of 
        joins and eliminates.

        If a factor that you are about to eliminate a variable from has 
        only one unconditioned variable, you should not eliminate it 
        and instead just discard the factor.  This is since the 
        result of the eliminate would be 1 (you marginalize 
        all of the unconditioned variables), but it is not a 
        valid factor.  So this simplifies using the result of eliminate.

        The sum of the probabilities should sum to one (so that it is a true 
        conditional probability, conditioned on the evidence).

        bayesNet:         The Bayes Net on which we are making a query.
        queryVariables:   A list of the variables which are unconditioned
                          in the inference query.
        evidenceDict:     An assignment dict {variable : value} for the
                          variables which are presented as evidence
                          (conditioned) in the inference query. 
        eliminationOrder: The order to eliminate the variables in.

        Hint: BayesNet.getAllCPTsWithEvidence will return all the Conditional 
        Probability Tables even if an empty dict (or None) is passed in for 
        evidenceDict. In this case it will not specialize any variable domains 
        in the CPTs.

        Useful functions:
        BayesNet.getAllCPTsWithEvidence
        normalize
        eliminate
        joinFactorsByVariable
        joinFactors
        """

        # this is for autograding -- don't modify
        joinFactorsByVariable = joinFactorsByVariableWithCallTracking(
            callTrackingList)
        eliminate = eliminateWithCallTracking(callTrackingList)
        if eliminationOrder is None:  # set an arbitrary elimination order if None given
            eliminationVariables = bayesNet.variablesSet() - set(queryVariables) -\
                                   set(evidenceDict.keys())
            eliminationOrder = sorted(list(eliminationVariables))

        "*** YOUR CODE HERE ***"
        """
        this section is heavily based on the "inferenceByEnumeration" section. 
        In "inferenceByEnumeration" section we would join all "joinVariable" 
        to the "currentFactorsList" according to:
        
        	    for joinVariable in bayesNet.variablesSet():
        		currentFactorsList, joinedFactor = joinFactorsByVariable(currentFactorsList, joinVariable)
		        currentFactorsList.append(joinedFactor)
	
	and then eliminate by:
	
		    for eliminationVariable in eliminationVariables:
        		incrementallyMarginalizedJoint = eliminate(incrementallyMarginalizedJoint, eliminationVariable)
   		    fullJointOverQueryAndEvidence = incrementallyMarginalizedJoint

        and then normalize so that the probability sums to one
        	    
        	    queryConditionedOnEvidence = normalize(fullJointOverQueryAndEvidence)
        
        and then return "queryConditionedOnEvidence"
        
        
        
        
        NOW, for "inferenceByVariableElimination" we would heavily use the same 
        method but instead of adding all of them together and then removing 
        all together, we would add one and then remove the same:
        
        to achieve this task we would loop through all the "eliminationOrder" 
        and form a "currentFactorsList" with the "joinedFactor" and "elimVariable"
           	
           	 currentFactorsList, joinedFactor = joinFactorsByVariable(currentFactorsList, elimVariable)
           	 
        then I would eliminate "elimVariable" from "joinedFactor" as long as 
        there is at least more than 1 variable in the unconditioned in the 
        "joinedFactor". I am not fully sure why I have to do it but the comments 
        above say:
        
	        If a factor that you are about to eliminate a variable from has 
	        only one unconditioned variable, you should not eliminate it 
       		and instead just discard the factor.  This is since the 
        	result of the eliminate would be 1 (you marginalize 
        	all of the unconditioned variables), but it is not a 
        	valid factor.  So this simplifies using the result of eliminate. 
        
        I guess the reason is that if there is only one unconditioned in the 
        joint and we remove them there would be no unconditioned left in joint.
        if there is only 1 unconditioned this is what happens:
        
        	P(A|B).P(B) = P(A,B) --> end of it --> cant eliminate B from P(A,B)
        
        once the currentfactorList is updated a new factors list is generated
        and the normalized result is returned. 
        
        	finalFactorsList = joinFactors(currentFactorsList)
        	finalFactorsListNormalized = normalize(finalFactorsList)

   
        """

        #util.raiseNotDefined()

        "generate the current factor list. this list will be updated on the road"
        currentFactorsList = bayesNet.getAllCPTsWithEvidence(evidenceDict)

        "loop through the elimination parameters and thenjoin and remove"
        for elimVariable in eliminationOrder:
            #print currentFactorsList

            "add the elimVariable and generate join"
            currentFactorsList, joinedFactor = joinFactorsByVariable(
                currentFactorsList, elimVariable)

            #print joinedFactor
            #print currentFactorsList

            "if unconditioned are larger or equal to 2 then remove from joinedFactor"
            numUncontiotioned = len(joinedFactor.unconditionedVariables())
            if numUncontiotioned >= 2:
                incrementallyMarginalizedJoint = eliminate(
                    joinedFactor, elimVariable)
                currentFactorsList.append(incrementallyMarginalizedJoint)
            #print "incrementallyMarginalizedJoint", incrementallyMarginalizedJoint
            #print currentFactorsList
            "otherwise this is the end of the add and remove --> do nothing"

        "generate final factor list join out of the updated currentFactorsList"
        finalFactorsList = joinFactors(currentFactorsList)
        #print finalFactorsList

        "normalize"
        finalFactorsListNormalized = normalize(finalFactorsList)

        return finalFactorsListNormalized