def test_exhaustive_enumeration(self): a = DiscreteFactor([(0, 2), (1, 3)], data=np.array([[1, 2, 3], [4, 5, 6]])) b = DiscreteFactor([(0, 2), (2, 2)], data=np.array([[1, 2], [2, 1]])) # 0 1 2 | #-------+-------- # 0 0 0 | 1x1=1 # 0 0 1 | 1x2=2 # 0 1 0 | 2x1=2 # 0 1 1 | 2x2=4 # 0 2 0 | 3x1=3 # 0 2 1 | 3x2=6 # 1 0 0 | 4x2=8 # 1 0 1 | 4x1=4 # 1 1 0 | 5x2=10 # 1 1 1 | 5x1=5 # 1 2 0 | 6x2=12 # 1 2 1 | 6x1=6 model = Model([a, b]) exact_inference = ExhaustiveEnumeration(model) c = exact_inference.calibrate().belief d = DiscreteFactor([(0, 2), (1, 3), (2, 2)]) d._data = np.array([1, 2, 2, 4, 3, 6, 8, 4, 10, 5, 12, 6]).reshape(2, 3, 2) self.assertEqual(d.variables, c.variables) self.assertEqual(d.axis_to_variable, c.axis_to_variable) assert_array_almost_equal(d._data, c.data)
def test_marginalize_larger(self): data = np.array([[[1, 2], [5, 8], [9, 10]], [[11, 12], [15, 18], [19, 21]]]) a = DiscreteFactor([(0, 2), (4, 3), (20, 2)], data=data) data = np.array([35, 96]) c = DiscreteFactor([(0, 2)], data=data) b = a.marginalize([0]) print b.data print c.data print b.data.shape print c.data.shape self.assertEqual(b.variables, c.variables) self.assertEqual(b.axis_to_variable, c.axis_to_variable) assert_array_almost_equal(b.data, c.data) data = np.array([[12, 14], [20, 26], [28, 31]]) e = DiscreteFactor([(4, 3), (20, 2)], data=data) d = a.marginalize([4, 20]) print d.data print e.data print d.data.shape print e.data.shape self.assertEqual(d.variables, e.variables) self.assertEqual(d.axis_to_variable, e.axis_to_variable) assert_array_almost_equal(d.data, e.data)
def test_marginalize_small(self): data = np.array([[1, 2], [5, 8]]) a = DiscreteFactor([(0, 2), (1, 2)], data=data) data = np.array([3, 13]) c = DiscreteFactor([(0, 2)], data=data) b = a.marginalize([0]) print b.data print c.data print b.data.shape print c.data.shape self.assertEqual(b.variables, c.variables) self.assertEqual(b.axis_to_variable, c.axis_to_variable) assert_array_almost_equal(b.data, c.data) data = np.array([6, 10]) e = DiscreteFactor([(1, 2)], data) d = a.marginalize([1]) print d.data print e.data print d.data.shape print e.data.shape self.assertEqual(d.variables, e.variables) self.assertEqual(d.axis_to_variable, e.axis_to_variable) assert_array_almost_equal(d.data, e.data)
def test_marginalize_small_edge(self): data = np.array([[0, 2], [5, 8]]) a = DiscreteFactor([(0, 2), (1, 2)], data=data) print a.data b = a.marginalize([0, 1]) print print b.data print b.data.shape self.assertEqual(b.variables, a.variables) self.assertEqual(b.axis_to_variable, a.axis_to_variable) assert_array_almost_equal(b.data, a.data) c = a.marginalize([1, 0]) print c.data print c.data.shape self.assertEqual(c.variables, a.variables) self.assertEqual(c.axis_to_variable, a.axis_to_variable) assert_array_almost_equal(c.data, a.data)
def construct_graph(patch_images, context_image, pw, stride): """ Drawn heavily from this example notebook http://nbviewer.jupyter.org/github/dirko/pyugm/blob/master/examples/Loopy%20belief%20propagation%20example.ipynb on how to use the pyugm package This will create a graph with observation factors (create_ovservation_comps) and label factors (create_neighbor_matrix) s.t. we reward using patches from one of the K style imgs that is close to our source image while also rewarding smoothness between the chosen patches (this is done through the neighbor label factors) inputs patch_image_directory- directory where stylized imgs are located. context_image- the context image as a np array pw- patch width stride- step size between each patch outputs evidence- context values associated with each observed variable factors- the lines on our graph; they relate the style patch to the context patch and relate style patches to other style patches (for neighbors) """ evidence = {} factors = [] K = len(patch_images) source_rows = context_image.shape[0] source_cols = context_image.shape[1] # Add observation factors for r in range(0, source_rows - pw + 1, stride): for c in range(0, source_cols - pw + 1, stride): # do this for each patch in the source image # call create_observation_comps to make the parameters label_variable_name = 'label_{}_{}'.format(r, c) observation_variable_name = 'obs_{}_{}'.format(r, c) print("\nadded label %s and observation %s" % (label_variable_name, observation_variable_name)) print("these two are linked by a factor") observation_params = create_oberservation_comps( patch_images, context_image, (r, c), pw) factors.append( DiscreteFactor([(label_variable_name, K), (observation_variable_name, 256)], parameters=observation_params)) evidence[observation_variable_name] = context_image[r:r + pw, c:c + pw, :] # Add label factors # for each patch location in a texture image # create a node for it and get the 4 neighbor matrices from the helper function # then create the neighbors-factors if appropriate # as said below, maybe just start with doing down and right for r in range(0, source_rows - pw + 1, stride): for c in range(0, source_cols - pw + 1, stride): variable_name = 'label_{}_{}'.format(r, c) neighbor_params, neighbor_locs = create_neighbor_matrix( patch_images, (r, c), pw, stride) print("\nLooking at label %s" % variable_name) # for each valid neighbor, create a factor for np, nl in zip(neighbor_params, neighbor_locs): if np is None or nl is None: continue r, c = nl neighbor_name = 'label_{}_{}'.format(r, c) print("adding neighbor ", neighbor_name) factors.append( DiscreteFactor([(variable_name, K), (neighbor_name, K)], parameters=np)) return evidence, factors
def test_get_potential_slice(self): a = DiscreteFactor([(4, 2), (8, 3)], data=np.array(range(6)).reshape(2, 3)) b = a.get_potential([(8, 0), (9, 1), (2, 4)]) self.assertIsNone(assert_array_almost_equal(b, np.array([0, 3])))
def test_get_potential_single(self): a = DiscreteFactor([(4, 2), (8, 3)], data=np.array(range(6)).reshape(2, 3)) b = a.get_potential([(8, 0), (4, 1), (2, 4)]) print b self.assertAlmostEqual(b, 3)