コード例 #1
0
def test_mrf_EM():
    """EXAMPLE: EM learning on a MRF"""
    """Define MRF graph structure"""
    C = 0
    S = 1
    R = 2
    W = 3
    nodes = 4
    adj_mat = sparse.lil_matrix((nodes, nodes), dtype=int)
    adj_mat[C, [R, S]] = 1
    adj_mat[R, W] = 1
    adj_mat[S, W] = 1
    adj_mat[R, S] = 1

    """Define clique domains and node sizes"""
    ns = 2 * np.ones((1, nodes))
    clq_doms = [[0], [0, 1], [0, 2], [1, 2, 3]]

    """Define cliques and potentials"""
    clqs = []
    clqs.append(cliques.discrete_clique(0, clq_doms[0], np.array([2])))
    clqs.append(cliques.discrete_clique(1, clq_doms[1], np.array([2, 2])))
    clqs.append(cliques.discrete_clique(2, clq_doms[2], np.array([2, 2])))
    clqs.append(cliques.discrete_clique(3, clq_doms[3], np.array([2, 2, 2])))

    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs)
    
    """
    Load the samples, and set one sample of one node to be unobserved, this
    should not effect the learnt parameter much, and will demonstrate that
    the algorithm can handle unobserved samples.
    """
    samples = (np.array(pylab.load('./Data/lawn_samples.txt')) - 1).tolist()
    samples[0][0] = []

    """Learn the parameters"""
    net.learn_params_EM(samples[:])
   
    """Initialize the inference engine"""
    net.init_inference_engine(exact=True)

    """Create and enter evidence"""
    evidences = create_all_evidence(4, 2)
    mlcs = np.array([[0, 0, 0, 0]])
    for evidence in evidences:
        mlc = net.max_sum(evidence)
        mlcs = np.vstack((mlcs, mlc))
   
    """Read in expected values"""
    exp_mlcs = np.array(pylab.load('./Data/mrf_em_exact_max_sum_res.txt'))

    """Assert that the output matched the expected values"""
    assert_array_equal(mlcs, exp_mlcs)
コード例 #2
0
def test_mrf_exact_sum_product():
    """EXAMPLE: Junction tree sum-product on MRF"""
    """Define MRF graph structure"""
    C = 0
    S = 1
    R = 2
    W = 3
    nodes = 4
    adj_mat = sparse.lil_matrix((nodes, nodes), dtype=int)
    adj_mat[C, [R, S]] = 1
    adj_mat[R, W] = 1
    adj_mat[S, W] = 1
    adj_mat[R, S] = 1
    """Define clique domains and node sizes"""
    ns = 2 * np.ones((1, nodes))
    clq_doms = [[0, 1, 2], [1, 2, 3]]
    """Define cliques and potentials"""
    clqs = []
    T = np.zeros((2, 2, 2))
    T[:, :, 0] = np.array([[0.2, 0.2], [0.09, 0.01]])
    T[:, :, 1] = np.array([[0.05, 0.05], [0.36, 0.04]])
    clqs.append(cliques.discrete_clique(0, clq_doms[0], np.array([2, 2, 2]),
                                        T))
    T[:, :, 0] = np.array([[1, 0.1], [0.1, 0.01]])
    T[:, :, 1] = np.array([[0, 0.9], [0.9, 0.99]])
    clqs.append(cliques.discrete_clique(1, clq_doms[1], np.array([2, 2, 2]),
                                        T))
    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs)
    net.init_inference_engine(exact=True)
    """Create and enter evidence"""
    evidences = create_all_evidence(4, 2)
    results = []
    for evidence in evidences:
        net.sum_product(evidence)
        result = []
        result.append(np.max(net.marginal_nodes([0]).T))
        result.append(np.max(net.marginal_nodes([1]).T))
        result.append(np.max(net.marginal_nodes([2]).T))
        result.append(np.max(net.marginal_nodes([3]).T))
        results.append(result)

    results = np.array(results)
    """Get the expected results"""
    exp_results = np.array(pylab.load('./Data/mrf_exact_sum_product_res.txt'))
    """Assert that the output matched the expected values"""
    assert_array_equal(results, exp_results)
コード例 #3
0
def test_mrf_EM():
    """EXAMPLE: EM learning on a MRF"""
    """Define MRF graph structure"""
    C = 0
    S = 1
    R = 2
    W = 3
    nodes = 4
    adj_mat = sparse.lil_matrix((nodes, nodes), dtype=int)
    adj_mat[C, [R, S]] = 1
    adj_mat[R, W] = 1
    adj_mat[S, W] = 1
    adj_mat[R, S] = 1
    """Define clique domains and node sizes"""
    ns = 2 * np.ones((1, nodes))
    clq_doms = [[0], [0, 1], [0, 2], [1, 2, 3]]
    """Define cliques and potentials"""
    clqs = []
    clqs.append(cliques.discrete_clique(0, clq_doms[0], np.array([2])))
    clqs.append(cliques.discrete_clique(1, clq_doms[1], np.array([2, 2])))
    clqs.append(cliques.discrete_clique(2, clq_doms[2], np.array([2, 2])))
    clqs.append(cliques.discrete_clique(3, clq_doms[3], np.array([2, 2, 2])))
    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs)
    """
    Load the samples, and set one sample of one node to be unobserved, this
    should not effect the learnt parameter much, and will demonstrate that
    the algorithm can handle unobserved samples.
    """
    samples = (np.array(pylab.load('./Data/lawn_samples.txt')) - 1).tolist()
    samples[0][0] = []
    """Learn the parameters"""
    net.learn_params_EM(samples[:])
    """Initialize the inference engine"""
    net.init_inference_engine(exact=True)
    """Create and enter evidence"""
    evidences = create_all_evidence(4, 2)
    mlcs = np.array([[0, 0, 0, 0]])
    for evidence in evidences:
        mlc = net.max_sum(evidence)
        mlcs = np.vstack((mlcs, mlc))
    """Read in expected values"""
    exp_mlcs = np.array(pylab.load('./Data/mrf_em_exact_max_sum_res.txt'))
    """Assert that the output matched the expected values"""
    assert_array_equal(mlcs, exp_mlcs)
コード例 #4
0
def test_mrf_approx_max_sum():
    """EXAMPLE: Loopy belief max-sum on MRF"""
    """Define MRF graph structure"""
    C = 0
    S = 1
    R = 2
    W = 3
    nodes = 4
    adj_mat = sparse.lil_matrix((nodes, nodes), dtype=int)
    adj_mat[C, [R, S]] = 1
    adj_mat[R, W] = 1
    adj_mat[S, W] = 1
    adj_mat[R, S] = 1
    """Define clique domains and node sizes"""
    ns = 2 * np.ones((1, nodes))
    clq_doms = [[0, 1, 2], [1, 2, 3]]
    """Define cliques and potentials"""
    clqs = []
    T = np.zeros((2, 2, 2))
    T[:, :, 0] = np.array([[0.2, 0.2], [0.09, 0.01]])
    T[:, :, 1] = np.array([[0.05, 0.05], [0.36, 0.04]])
    clqs.append(cliques.discrete_clique(0, clq_doms[0], np.array([2, 2, 2]),
                                        T))
    T[:, :, 0] = np.array([[1, 0.1], [0.1, 0.01]])
    T[:, :, 1] = np.array([[0, 0.9], [0.9, 0.99]])
    clqs.append(cliques.discrete_clique(1, clq_doms[1], np.array([2, 2, 2]),
                                        T))
    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs)
    net.init_inference_engine(exact=False)
    """Create and enter evidence"""
    evidences = create_all_evidence(4, 2)
    mlcs = np.array([0, 0, 0, 0])
    for evidence in evidences:
        mlc = net.max_sum(evidence)
        mlcs = np.vstack((mlcs, mlc))
    """Read in expected values"""
    exp_mlcs = np.array(pylab.load('./Data/mrf_approx_max_sum_res.txt'))
    """Assert that the output matched the expected values"""
    assert_array_equal(mlcs, exp_mlcs)
コード例 #5
0
    nodes in the clique. A clique is a fully connected set of nodes.
    Therefore, for a set of node to be a clique, every node in the set must
    be connected to every other node in the set.
    """
    clq_doms = [[0], [0, 1], [0, 2], [1, 2, 3]]

    """Create blank cliques with the required domains and sizes"""
    clqs = []
    clqs.append(cliques.clique(0, clq_doms[0], np.array([2])))
    clqs.append(cliques.clique(1, clq_doms[1], np.array([2, 2])))
    clqs.append(cliques.clique(2, clq_doms[2], np.array([2, 2])))
    clqs.append(cliques.clique(3, clq_doms[3], np.array([2, 2, 2])))


    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs, lattice=False)

    """Define the samples that will be used to train the models parameters"""
    samples = \
           [[0, 1, 0, None],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
            [1, 0, 1, 0],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
            [0, 1, 1, 1],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
            [0, 1, 0, 1],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
コード例 #6
0
    Define the clique domains. The domain of a clique, is the indices of the
    nodes in the clique. A clique is a fully connected set of nodes.
    Therefore, for a set of node to be a clique, every node in the set must
    be connected to every other node in the set.
    """
    clq_doms = [[0], [0, 1], [0, 2], [1, 2, 3]]

    """Create blank cliques with the required domains and sizes"""
    clqs = []
    clqs.append(cliques.clique(0, clq_doms[0], np.array([2])))
    clqs.append(cliques.clique(1, clq_doms[1], np.array([2, 2])))
    clqs.append(cliques.clique(2, clq_doms[2], np.array([2, 2])))
    clqs.append(cliques.clique(3, clq_doms[3], np.array([2, 2, 2])))

    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs, lattice=False)

    """Define the samples that will be used to train the models parameters"""
    samples = \
           [[0, 1, 0, 0],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
            [1, 0, 1, 0],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
            [0, 1, 1, 1],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
            [0, 1, 0, 1],
            [0, 1, 0, 1],
            [1, 0, 1, 1],
コード例 #7
0
def denoise_image(img, depth=255, max_iter=10):
    """
    Denoises a single channel image.

    Parameters
    ----------
    img: Numpy array
        The image to denoise.

    depth: Int
        The number of different values a pixel can take.

    max_iter: Int
        The maximum number of times the inference algorithm can iterate.
    """
    """
    Create adjacency matrix representation of the hidden lattice graph that
    represents the denoised image.
    """
    print "Creating initial adjacency matrix..."
    adj_mat = create_lattice_sparse_adj_matrix(img.shape[0], img.shape[1], 2)

    print "Determine the cliques from the adjacency matrix..."   
    """Get the cliques as a list"""
    clq_doms = []
    i = 0
    for cols in adj_mat.rows:
        if len(cols) > 0:
            for col in cols:
                new_clique = [i, col]
                new_clique.sort()
                clq_doms.append(new_clique)
        i = i + 1

    """Create list of node sizes"""
    print "Creating list of node sizes..."
    ns = depth * np.ones((1, img.shape[0]*img.shape[1]*2))

    """Create list of cliques and assign potentials to them"""
    print "Creating the  list of cliques and their potentials..."
    """Image model"""
    T_img = create_img_prob_table(depth, 1)
    
    """Noise model"""
    T_noise = create_img_prob_table(depth, 5)

    clqs = []
    outer_layer = range(img.shape[0]*img.shape[1], img.shape[0]*img.shape[1]*2)
    for i in range(0, len(clq_doms)):
        if clq_doms[i][1] in outer_layer:
            clqs.append(cliques.discrete_clique(i, clq_doms[i], \
                                                np.array([depth, depth]),\
                                                T_img))
        else:
            clqs.append(cliques.discrete_clique(i, clq_doms[i], \
                                                np.array([depth, depth]), \
                                                T_noise))
            
    """Create the MRF object and set the lattice flag to TRUE"""
    print "Creating MRF..."
    net = models.mrf(adj_mat, ns, clqs, lattice=True)

    """Initialize the inference engine to be approximate"""
    net.init_inference_engine(exact=False, max_iter=max_iter)
   

    """Create the evidence, with the noisy nodes being observed"""
    evidence = img.flatten().tolist()
    N = len(evidence)
    for i in range(0, N):
        evidence.insert(0, [])

    """Run loopy-belief propagation"""
    print "Running loopy belief propagation..."    
    mlc = net.max_sum(evidence)

    """
    Extract denoised image from most likely configuaration of the hidden
    nodes.
    """
    print "Extracting denoised image..."
    new_img = np.array(mlc[0:img.shape[0]*img.shape[1]])
    new_img = np.array(new_img.reshape(img.shape[0], img.shape[1]))

    """Delete objects"""
    del img
    del adj_mat
    del net

    return new_img
コード例 #8
0
def test_mrf_sumproduct():
    """
    Testing: SUM-PRODUCT on MRF
    This example is based on the lawn sprinkler example, and the Markov
    random field has the following structure.

                            Cloudy - 0
                             /  \
                            /    \
                           /      \
                   Sprinkler - 1  Rainy - 2
                           \      /
                            \    /
                             \  /
                           Wet Grass -3                
    """
    """Assign a unique numerical identifier to each node"""
    C = 0
    S = 1
    R = 2
    W = 3

    """Assign the number of nodes in the graph"""
    nodes = 4

    """
    The graph structure is represented as a adjacency matrix, dag.
    If adj_mat[i, j] = 1, then there exists a undirected edge from node
    i and node j.
    """
    adj_mat = np.matrix(np.zeros((nodes, nodes)))
    adj_mat[C, [R, S]] = 1
    adj_mat[R, W] = 1
    adj_mat[S, W] = 1

    """
    Define the size of each node, which is the number of different values a
    node could observed at. For example, if a node is either True of False,
    it has only 2 possible values it could be, therefore its size is 2. All
    the nodes in this graph has a size 2.
    """
    ns = 2 * np.ones(nodes)

    """
    Define the clique domains. The domain of a clique, is the indices of the
    nodes in the clique. A clique is a fully connected set of nodes.
    Therefore, for a set of node to be a clique, every node in the set must
    be connected to every other node in the set.
    """
    clq_doms = [[0, 1, 2], [1, 2, 3]]

    """Define potentials for the cliques"""
    clqs = []
    T = np.zeros((2, 2, 2))
    T[:, :, 0] = np.array([[0.2, 0.2], [0.09, 0.01]])
    T[:, :, 1] = np.array([[0.05, 0.05], [0.36, 0.04]])
    clqs.append(cliques.clique(0, clq_doms[0], np.array([2, 2, 2]), T))
    T[:, :, 0] = np.array([[1, 0.1], [0.1, 0.01]])
    T[:, :, 1] = np.array([[0, 0.9], [0.9, 0.99]])
    clqs.append(cliques.clique(1, clq_doms[1], np.array([2, 2, 2]), T))

    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs, lattice=False)

    """
    Intialize the MRF's inference engine to use EXACT inference, by
    setting exact=True.
    """
    net.init_inference_engine(exact=True)

    """Create and enter evidence ([] means that node is unobserved)"""
    all_ev = sprinkler_evidence();
    all_prob = sprinkler_probs();

    count = 0;
    errors = 0;
    for evidence in all_ev:
        """Execute the max-sum algorithm"""
        net.sum_product(evidence)

        ans = [1, 1, 1, 1]
        marginal = net.marginal_nodes([C])

        if evidence[C] is None:
            ans[C] = marginal.T[1]
            
        marginal = net.marginal_nodes([S])
        if evidence[S] is None:
            ans[S] = marginal.T[1]
            
        marginal = net.marginal_nodes([R])
        if evidence[R] is None:
            ans[R] = marginal.T[1]
            
        marginal = net.marginal_nodes([W])
        if evidence[W] is None:
            ans[W] = marginal.T[1]

        errors = errors +  \
                 np.round(np.sum(np.array(ans) - np.array(all_prob[count])), 3)
        count = count + 1

    assert errors == 0
コード例 #9
0
def test_mrf_maxsum():
    """
    Testing: MAX-SUM of MRF
    This example is based on the lawn sprinkler example, and the Markov
    random field has the following structure.

                            Cloudy - 0
                             /  \
                            /    \
                           /      \
                   Sprinkler - 1  Rainy - 2
                           \      /
                            \    /
                             \  /
                           Wet Grass -3                
    """
    """Assign a unique numerical identifier to each node"""
    C = 0
    S = 1
    R = 2
    W = 3
    """Assign the number of nodes in the graph"""
    nodes = 4
    """
    The graph structure is represented as a adjacency matrix, dag.
    If adj_mat[i, j] = 1, then there exists a undirected edge from node
    i and node j.
    """
    adj_mat = np.matrix(np.zeros((nodes, nodes)))
    adj_mat[C, [R, S]] = 1
    adj_mat[R, W] = 1
    adj_mat[S, W] = 1
    """
    Define the size of each node, which is the number of different values a
    node could observed at. For example, if a node is either True of False,
    it has only 2 possible values it could be, therefore its size is 2. All
    the nodes in this graph has a size 2.
    """
    ns = 2 * np.ones(nodes)
    """
    Define the clique domains. The domain of a clique, is the indices of the
    nodes in the clique. A clique is a fully connected set of nodes.
    Therefore, for a set of node to be a clique, every node in the set must
    be connected to every other node in the set.
    """
    clq_doms = [[0, 1, 2], [1, 2, 3]]
    """Define potentials for the cliques"""
    clqs = []
    T = np.zeros((2, 2, 2))
    T[:, :, 0] = np.array([[0.2, 0.2], [0.09, 0.01]])
    T[:, :, 1] = np.array([[0.05, 0.05], [0.36, 0.04]])
    clqs.append(cliques.clique(0, clq_doms[0], np.array([2, 2, 2]), T))
    T[:, :, 0] = np.array([[1, 0.1], [0.1, 0.01]])
    T[:, :, 1] = np.array([[0, 0.9], [0.9, 0.99]])
    clqs.append(cliques.clique(1, clq_doms[1], np.array([2, 2, 2]), T))
    """Create the MRF"""
    net = models.mrf(adj_mat, ns, clqs, lattice=False)
    """
    Intialize the MRF's inference engine to use EXACT inference, by
    setting exact=True.
    """
    net.init_inference_engine(exact=True)
    """Create and enter evidence ([] means that node is unobserved)"""
    all_ev = sprinkler_evidence()
    all_mpe = sprinkler_mpe()

    count = 0
    errors = 0
    for evidence in all_ev:
        """Execute the max-sum algorithm"""
        mlc = net.max_sum(evidence)

        mpe = all_mpe[count]
        errors = errors + np.sum(np.array(mpe) - np.array(mlc))

        count = count + 1

    assert errors == 0