From 813cb50e926a90dff510cf3d81d3f0a4726b1f49 Mon Sep 17 00:00:00 2001 From: Ben Date: Wed, 25 Jan 2023 16:08:23 -0800 Subject: [PATCH 1/5] Add unit tests for the file test_visualization_manifold_of_categorical_distributions.py --- ...n_manifold_of_categorical_distributions.py | 246 ++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py diff --git a/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py b/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py new file mode 100644 index 000000000..0c93d624a --- /dev/null +++ b/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py @@ -0,0 +1,246 @@ +"""Unit tests for visualization.""" + +import matplotlib +import matplotlib.pyplot as plt +import numpy as np + +import geomstats.backend as gs +import geomstats.visualization as visualization +import tests.conftest +from geomstats.geometry.hyperbolic import Hyperbolic +from geomstats.geometry.hypersphere import Hypersphere +from geomstats.geometry.matrices import Matrices +from geomstats.geometry.poincare_half_space import PoincareHalfSpace +from geomstats.geometry.pre_shape import PreShapeSpace +from geomstats.geometry.spd_matrices import SPDMatrices +from geomstats.geometry.special_euclidean import SpecialEuclidean +from geomstats.geometry.special_orthogonal import ( + SpecialOrthogonal, + _SpecialOrthogonalMatrices, +) + +#Added +from CategoricalDistributionsManifold import CategoricalDistributionsManifold + +matplotlib.use("Agg") # NOQA + +class TestVisualization(tests.conftest.TestCase): + def setup_method(self): + self.n_samples = 10 + self.SO3_GROUP = SpecialOrthogonal(n=3, point_type="vector") + self.SE3_GROUP = SpecialEuclidean(n=3, point_type="vector") + self.S1 = Hypersphere(dim=1) + self.S2 = Hypersphere(dim=2) + self.H2 = Hyperbolic(dim=2) + self.H2_half_plane = PoincareHalfSpace(dim=2) + self.M32 = Matrices(m=3, n=2) + self.S32 = PreShapeSpace(k_landmarks=3, m_ambient=2) + self.KS = visualization.KendallSphere() + self.M33 = Matrices(m=3, n=3) + self.S33 = PreShapeSpace(k_landmarks=3, m_ambient=3) + self.KD = visualization.KendallDisk() + self.spd = SPDMatrices(n=2) + + #Added + self.CD2 = CategoricalDistributionsManifold(dim=2) + self.CD3 = CategoricalDistributionsManifold(dim=3) + + plt.figure() + + @staticmethod + def test_tutorial_matplotlib(): + visualization.tutorial_matplotlib() + #no upper case + ####Adding things ############################################# + def test_plot_Categorical_Distributions_Manifold(self): + self.CD2.plot() + self.CD3.plot() + #delete + def test_plot3D_Categorical_Distributions_Manifold(self): + self.CD2.plot3D() + self.CD3.plot3D() + + def test_scatter_Categorical_Distributions_Manifold(self): + self.CD2.scatter(self.n_samples) + self.CD3.scatter(self.n_samples) + + def test_set_points_Categorical_Distributions_Manifold(self): + self.CD2.set_points(self.n_samples) + + def test_plot_geodesic_Categorical_Distributions_Manifold(self): + b2 = np.array([0.2,0.3,0.5]) + v2 = np.array([1,0,0]) + self.CD2.plot_geodesic(v2,b2) + #we get failure here for b3 and v3 + #b3 = np.array([0.3,0.3,0.2,0.2]) + #v3 = np.array([1,0,0,0]) + #self.CD3.plot_geodesic(v3,b3) + + def test_plot_log_Categorical_Distributions_Manifold(self): + end2 = np.array([0.2,0.3,0.5]) + base2 = np.array([0,0,1]) + self.CD2.plot_log(end2,base2) + + end3 = np.array([0.1,0.2,0.3,0.4]) + base3 = np.array([1,0,0,0]) + self.CD3.plot_log(end3,base3) + + def test_plot_exp_Categorical_Distributions_Manifold(self): + b2 = np.array([0.2,0.3,0.5]) + v2 = np.array([1,0,0]) + self.CD2.plot_exp(v2,b2) + + b3 = np.array([0.1,0.2,0.3,0.4]) + v3 = np.array([1,0,0,0]) + self.CD3.plot_exp(v3,b3) +############################################################################ + def test_plot_points_so3(self): + points = self.SO3_GROUP.random_uniform(self.n_samples) + visualization.plot(points, space="SO3_GROUP") + + def test_plot_points_se3(self): + points = self.SE3_GROUP.random_point(self.n_samples) + visualization.plot(points, space="SE3_GROUP") + + def test_draw_pre_shape_2d(self): + self.KS.draw() + + def test_draw_points_pre_shape_2d(self): + points = self.S32.random_point(self.n_samples) + visualization.plot(points, space="S32") + points = self.M32.random_point(self.n_samples) + visualization.plot(points, space="M32") + self.KS.clear_points() + + def test_draw_curve_pre_shape_2d(self): + self.KS.draw() + base_point = self.S32.random_point() + vec = self.S32.random_point() + tangent_vec = self.S32.to_tangent(vec, base_point) + times = gs.linspace(0.0, 1.0, 1000) + speeds = gs.array([-t * tangent_vec for t in times]) + points = self.S32.total_space_metric.exp(speeds, base_point) + self.KS.add_points(points) + self.KS.draw_curve() + self.KS.clear_points() + + def test_draw_vector_pre_shape_2d(self): + self.KS.draw() + base_point = self.S32.random_point() + vec = self.S32.random_point() + tangent_vec = self.S32.to_tangent(vec, base_point) + self.KS.draw_vector(tangent_vec, base_point) + + def test_convert_to_spherical_coordinates_pre_shape_2d(self): + points = self.S32.random_point(self.n_samples) + coords = self.KS.convert_to_spherical_coordinates(points) + x = coords[:, 0] + y = coords[:, 1] + z = coords[:, 2] + result = x**2 + y**2 + z**2 + expected = 0.25 * gs.ones(self.n_samples) + self.assertAllClose(result, expected) + + def test_rotation_pre_shape_2d(self): + theta = gs.random.rand(1)[0] + phi = gs.random.rand(1)[0] + rot = self.KS.rotation(theta, phi) + result = _SpecialOrthogonalMatrices(3).belongs(rot) + expected = True + self.assertAllClose(result, expected) + + def test_draw_pre_shape_3d(self): + self.KD.draw() + + def test_draw_points_pre_shape_3d(self): + points = self.S33.random_point(self.n_samples) + visualization.plot(points, space="S33") + points = self.M33.random_point(self.n_samples) + visualization.plot(points, space="M33") + self.KD.clear_points() + + def test_draw_curve_pre_shape_3d(self): + self.KD.draw() + base_point = self.S33.random_point() + vec = self.S33.random_point() + tangent_vec = self.S33.to_tangent(vec, base_point) + tangent_vec = 0.5 * tangent_vec / self.S33.total_space_metric.norm(tangent_vec) + times = gs.linspace(0.0, 1.0, 1000) + speeds = gs.array([-t * tangent_vec for t in times]) + points = self.S33.total_space_metric.exp(speeds, base_point) + self.KD.add_points(points) + self.KD.draw_curve() + self.KD.clear_points() + + def test_draw_vector_pre_shape_3d(self): + self.KS.draw() + base_point = self.S32.random_point() + vec = self.S32.random_point() + tangent_vec = self.S32.to_tangent(vec, base_point) + self.KS.draw_vector(tangent_vec, base_point) + + def test_convert_to_planar_coordinates_pre_shape_3d(self): + points = self.S33.random_point(self.n_samples) + coords = self.KD.convert_to_planar_coordinates(points) + x = coords[:, 0] + y = coords[:, 1] + radius = x**2 + y**2 + result = [r <= 1.0 for r in radius] + self.assertTrue(gs.all(result)) + + def test_plot_points_s1(self): + points = self.S1.random_uniform(self.n_samples) + visualization.plot(points, space="S1") + + def test_plot_points_s2(self): + points = self.S2.random_uniform(self.n_samples) + visualization.plot(points, space="S2") + + def test_plot_points_h2_poincare_disk(self): + points = self.H2.random_point(self.n_samples) + visualization.plot(points, space="H2_poincare_disk") + + def test_plot_points_h2_poincare_half_plane_ext(self): + points = self.H2.random_point(self.n_samples) + visualization.plot( + points, space="H2_poincare_half_plane", coords_type="extrinsic" + ) + + def test_plot_points_h2_poincare_half_plane_none(self): + points = self.H2_half_plane.random_point(self.n_samples) + visualization.plot(points, space="H2_poincare_half_plane") + + def test_plot_points_h2_poincare_half_plane_hs(self): + points = self.H2_half_plane.random_point(self.n_samples) + visualization.plot( + points, space="H2_poincare_half_plane", coords_type="half_space" + ) + + def test_plot_points_h2_klein_disk(self): + points = self.H2.random_point(self.n_samples) + visualization.plot(points, space="H2_klein_disk") + + @staticmethod + def test_plot_points_se2(): + points = SpecialEuclidean(n=2, point_type="vector").random_point(4) + visu = visualization.SpecialEuclidean2(points, point_type="vector") + ax = visu.set_ax() + visu.draw_points(ax) + + def test_plot_points_spd2(self): + one_point = self.spd.random_point() + visualization.plot(one_point, space="SPD2") + + points = self.spd.random_point(4) + visualization.plot(points, space="SPD2") + + def test_compute_coordinates_spd2(self): + point = gs.eye(2) + ellipsis = visualization.Ellipses(k_sampling_points=4) + x, y = ellipsis.compute_coordinates(point) + self.assertAllClose(x, gs.array([1, 0, -1, 0, 1])) + self.assertAllClose(y, gs.array([0, 1, 0, -1, 0])) + + @staticmethod + def teardown_method(): + plt.close() \ No newline at end of file From f357911093a8b188c1b2e38dfb8b429241f40a13 Mon Sep 17 00:00:00 2001 From: Ben Date: Sat, 28 Jan 2023 17:40:40 -0800 Subject: [PATCH 2/5] Add unit test for the file test_visualisation_manifold_of_categorical_distributions.py --- ...n_manifold_of_categorical_distributions.py | 228 ++---------------- 1 file changed, 15 insertions(+), 213 deletions(-) diff --git a/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py b/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py index 0c93d624a..96e6d9158 100644 --- a/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py +++ b/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py @@ -7,240 +7,42 @@ import geomstats.backend as gs import geomstats.visualization as visualization import tests.conftest -from geomstats.geometry.hyperbolic import Hyperbolic -from geomstats.geometry.hypersphere import Hypersphere -from geomstats.geometry.matrices import Matrices -from geomstats.geometry.poincare_half_space import PoincareHalfSpace -from geomstats.geometry.pre_shape import PreShapeSpace -from geomstats.geometry.spd_matrices import SPDMatrices -from geomstats.geometry.special_euclidean import SpecialEuclidean -from geomstats.geometry.special_orthogonal import ( - SpecialOrthogonal, - _SpecialOrthogonalMatrices, -) -#Added from CategoricalDistributionsManifold import CategoricalDistributionsManifold matplotlib.use("Agg") # NOQA -class TestVisualization(tests.conftest.TestCase): +class TestVisualizationManifoldOfCategoricalDistributions(tests.conftest.TestCase): def setup_method(self): self.n_samples = 10 - self.SO3_GROUP = SpecialOrthogonal(n=3, point_type="vector") - self.SE3_GROUP = SpecialEuclidean(n=3, point_type="vector") - self.S1 = Hypersphere(dim=1) - self.S2 = Hypersphere(dim=2) - self.H2 = Hyperbolic(dim=2) - self.H2_half_plane = PoincareHalfSpace(dim=2) - self.M32 = Matrices(m=3, n=2) - self.S32 = PreShapeSpace(k_landmarks=3, m_ambient=2) - self.KS = visualization.KendallSphere() - self.M33 = Matrices(m=3, n=3) - self.S33 = PreShapeSpace(k_landmarks=3, m_ambient=3) - self.KD = visualization.KendallDisk() - self.spd = SPDMatrices(n=2) - - #Added self.CD2 = CategoricalDistributionsManifold(dim=2) self.CD3 = CategoricalDistributionsManifold(dim=3) - plt.figure() - @staticmethod + @staticmethod def test_tutorial_matplotlib(): visualization.tutorial_matplotlib() - #no upper case - ####Adding things ############################################# - def test_plot_Categorical_Distributions_Manifold(self): + + def test_plot(self): self.CD2.plot() self.CD3.plot() - #delete - def test_plot3D_Categorical_Distributions_Manifold(self): - self.CD2.plot3D() - self.CD3.plot3D() - def test_scatter_Categorical_Distributions_Manifold(self): + def test_scatter(self): self.CD2.scatter(self.n_samples) self.CD3.scatter(self.n_samples) - - def test_set_points_Categorical_Distributions_Manifold(self): - self.CD2.set_points(self.n_samples) - - def test_plot_geodesic_Categorical_Distributions_Manifold(self): - b2 = np.array([0.2,0.3,0.5]) - v2 = np.array([1,0,0]) - self.CD2.plot_geodesic(v2,b2) - #we get failure here for b3 and v3 - #b3 = np.array([0.3,0.3,0.2,0.2]) - #v3 = np.array([1,0,0,0]) - #self.CD3.plot_geodesic(v3,b3) - - def test_plot_log_Categorical_Distributions_Manifold(self): - end2 = np.array([0.2,0.3,0.5]) - base2 = np.array([0,0,1]) - self.CD2.plot_log(end2,base2) - - end3 = np.array([0.1,0.2,0.3,0.4]) - base3 = np.array([1,0,0,0]) - self.CD3.plot_log(end3,base3) - - def test_plot_exp_Categorical_Distributions_Manifold(self): + + def test_plot_geodesic(self): b2 = np.array([0.2,0.3,0.5]) - v2 = np.array([1,0,0]) - self.CD2.plot_exp(v2,b2) + v2 = np.array([1,0,0]) + self.CD2.plot_geodesic(initial_point=b2, tangent_vector=v2) - b3 = np.array([0.1,0.2,0.3,0.4]) + b3 = np.array([0.3,0.3,0.2,0.2]) v3 = np.array([1,0,0,0]) - self.CD3.plot_exp(v3,b3) -############################################################################ - def test_plot_points_so3(self): - points = self.SO3_GROUP.random_uniform(self.n_samples) - visualization.plot(points, space="SO3_GROUP") - - def test_plot_points_se3(self): - points = self.SE3_GROUP.random_point(self.n_samples) - visualization.plot(points, space="SE3_GROUP") - - def test_draw_pre_shape_2d(self): - self.KS.draw() - - def test_draw_points_pre_shape_2d(self): - points = self.S32.random_point(self.n_samples) - visualization.plot(points, space="S32") - points = self.M32.random_point(self.n_samples) - visualization.plot(points, space="M32") - self.KS.clear_points() - - def test_draw_curve_pre_shape_2d(self): - self.KS.draw() - base_point = self.S32.random_point() - vec = self.S32.random_point() - tangent_vec = self.S32.to_tangent(vec, base_point) - times = gs.linspace(0.0, 1.0, 1000) - speeds = gs.array([-t * tangent_vec for t in times]) - points = self.S32.total_space_metric.exp(speeds, base_point) - self.KS.add_points(points) - self.KS.draw_curve() - self.KS.clear_points() - - def test_draw_vector_pre_shape_2d(self): - self.KS.draw() - base_point = self.S32.random_point() - vec = self.S32.random_point() - tangent_vec = self.S32.to_tangent(vec, base_point) - self.KS.draw_vector(tangent_vec, base_point) - - def test_convert_to_spherical_coordinates_pre_shape_2d(self): - points = self.S32.random_point(self.n_samples) - coords = self.KS.convert_to_spherical_coordinates(points) - x = coords[:, 0] - y = coords[:, 1] - z = coords[:, 2] - result = x**2 + y**2 + z**2 - expected = 0.25 * gs.ones(self.n_samples) - self.assertAllClose(result, expected) - - def test_rotation_pre_shape_2d(self): - theta = gs.random.rand(1)[0] - phi = gs.random.rand(1)[0] - rot = self.KS.rotation(theta, phi) - result = _SpecialOrthogonalMatrices(3).belongs(rot) - expected = True - self.assertAllClose(result, expected) - - def test_draw_pre_shape_3d(self): - self.KD.draw() - - def test_draw_points_pre_shape_3d(self): - points = self.S33.random_point(self.n_samples) - visualization.plot(points, space="S33") - points = self.M33.random_point(self.n_samples) - visualization.plot(points, space="M33") - self.KD.clear_points() - - def test_draw_curve_pre_shape_3d(self): - self.KD.draw() - base_point = self.S33.random_point() - vec = self.S33.random_point() - tangent_vec = self.S33.to_tangent(vec, base_point) - tangent_vec = 0.5 * tangent_vec / self.S33.total_space_metric.norm(tangent_vec) - times = gs.linspace(0.0, 1.0, 1000) - speeds = gs.array([-t * tangent_vec for t in times]) - points = self.S33.total_space_metric.exp(speeds, base_point) - self.KD.add_points(points) - self.KD.draw_curve() - self.KD.clear_points() - - def test_draw_vector_pre_shape_3d(self): - self.KS.draw() - base_point = self.S32.random_point() - vec = self.S32.random_point() - tangent_vec = self.S32.to_tangent(vec, base_point) - self.KS.draw_vector(tangent_vec, base_point) - - def test_convert_to_planar_coordinates_pre_shape_3d(self): - points = self.S33.random_point(self.n_samples) - coords = self.KD.convert_to_planar_coordinates(points) - x = coords[:, 0] - y = coords[:, 1] - radius = x**2 + y**2 - result = [r <= 1.0 for r in radius] - self.assertTrue(gs.all(result)) - - def test_plot_points_s1(self): - points = self.S1.random_uniform(self.n_samples) - visualization.plot(points, space="S1") - - def test_plot_points_s2(self): - points = self.S2.random_uniform(self.n_samples) - visualization.plot(points, space="S2") - - def test_plot_points_h2_poincare_disk(self): - points = self.H2.random_point(self.n_samples) - visualization.plot(points, space="H2_poincare_disk") - - def test_plot_points_h2_poincare_half_plane_ext(self): - points = self.H2.random_point(self.n_samples) - visualization.plot( - points, space="H2_poincare_half_plane", coords_type="extrinsic" - ) - - def test_plot_points_h2_poincare_half_plane_none(self): - points = self.H2_half_plane.random_point(self.n_samples) - visualization.plot(points, space="H2_poincare_half_plane") - - def test_plot_points_h2_poincare_half_plane_hs(self): - points = self.H2_half_plane.random_point(self.n_samples) - visualization.plot( - points, space="H2_poincare_half_plane", coords_type="half_space" - ) - - def test_plot_points_h2_klein_disk(self): - points = self.H2.random_point(self.n_samples) - visualization.plot(points, space="H2_klein_disk") - - @staticmethod - def test_plot_points_se2(): - points = SpecialEuclidean(n=2, point_type="vector").random_point(4) - visu = visualization.SpecialEuclidean2(points, point_type="vector") - ax = visu.set_ax() - visu.draw_points(ax) - - def test_plot_points_spd2(self): - one_point = self.spd.random_point() - visualization.plot(one_point, space="SPD2") - - points = self.spd.random_point(4) - visualization.plot(points, space="SPD2") - - def test_compute_coordinates_spd2(self): - point = gs.eye(2) - ellipsis = visualization.Ellipses(k_sampling_points=4) - x, y = ellipsis.compute_coordinates(point) - self.assertAllClose(x, gs.array([1, 0, -1, 0, 1])) - self.assertAllClose(y, gs.array([0, 1, 0, -1, 0])) - + self.CD3.plot_geodesic(initial_point = b3, tangent_vector =v3) + + def test_plot_grid(self): + self.CD2.plot_grid() + @staticmethod def teardown_method(): plt.close() \ No newline at end of file From 9b081015e2b7122a94bab7ad9cb33a4ab7d47830 Mon Sep 17 00:00:00 2001 From: Ben Date: Sat, 28 Jan 2023 17:45:29 -0800 Subject: [PATCH 3/5] Add visualization for Manifold of Categorical Distributions as CategoricalDistributionsManifold.py --- .../CategoricalDistributionsManifold.py | 484 ++++++++++++++++++ 1 file changed, 484 insertions(+) create mode 100644 geomstats/visualization/CategoricalDistributionsManifold.py diff --git a/geomstats/visualization/CategoricalDistributionsManifold.py b/geomstats/visualization/CategoricalDistributionsManifold.py new file mode 100644 index 000000000..b409dc037 --- /dev/null +++ b/geomstats/visualization/CategoricalDistributionsManifold.py @@ -0,0 +1,484 @@ +import numpy as np +from geomstats.information_geometry.categorical import ( + CategoricalDistributions, CategoricalMetric) +from matplotlib import pyplot as plt +from mpl_toolkits.mplot3d.art3d import Poly3DCollection + + +class CategoricalDistributionsManifold: + r"""Class for visualizing the manifold of categorical distributions. + + This is the set of $n+1$-tuples of positive reals that sum up to one, + i.e. the $n$-simplex. Each point is the parameter of a categorical + distribution, i.e. gives the probabilities of $n$ different outcomes + in a single experiment. + + Attributes: + ----------- + dim : integer + Dimension of the manifold. + points: array-like, [[..., dim + 1], [..., dim + 1], ... ] + Discrete points to be plotted on the manifold. + + Notes: + ------ + The class only implements visualization methods for 2D and 3D manifolds. + """ + + def __init__(self, dim): + """Construct a CategoricalDistributionsManifold object. + + Construct a CategoricalDistributionsManifold with a given dimension. + + Parameters: + ----------- + dim : integer + Dimension of the manifold + + Returns: + -------- + None. + + Notes: + ------ + dim should be a positive integer. + The methods only support visualization of 2-D and 3-D manifolds. + """ + self.dim = dim + self.points = [] + self.ax = None + self.elev, self.azim = None, None + self.metric = CategoricalMetric(dim=self.dim) + self.dist = CategoricalDistributions(dim=self.dim) + + def plot(self): + """Plot the 2D or 3D Manifold. + + Plot the 2D Manifold as a regular 2-simplex(triangle) or + the 3D Manifold as a regular 3-simplex(tetrahedral). + + Parameters + ---------- + None. + + Returns + ------- + None. + + Notes + ----- + This method only works properly if the dimension is 2 or 3. + + References + ---------- + Simplex: https://en.wikipedia.org/wiki/Simplex + """ + min_limit = 0 + max_limit = 1 + plt.figure(dpi=100) + self.set_axis(min_limit, max_limit) + if self.dim == 3: + self.set_view() + x = [0, 1, 0, 0] + y = [0, 0, 1, 0] + z = [0, 0, 0, 1] + vertices = [[0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]] + tupleList = list(zip(x, y, z)) + poly3d = [ + [tupleList[vertices[ix][iy]] for iy in range(len(vertices[0]))] + for ix in range(len(vertices)) + ] + self.ax.add_collection3d( + Poly3DCollection( + poly3d, + edgecolors="k", + facecolors=(0.9, 0.9, 0.9, 1.0), + linewidths=3, + alpha=0.2, + ) + ) + + elif self.dim == 2: + X = np.linspace(start=min_limit, stop=max_limit, num=101, + endpoint=True) + Y = 1 - X + self.ax.fill_between(X, Y, color=(0.9, 0.9, 0.9, 1.0)) + self.ax.set_title("2 Dimension Categorical Manifold") + + def set_points(self, points): + self.points = points + + def scatter(self, n_samples, **scatter_kwargs): + """Scatter plot some randomly sampled points in the manifold. + + Plot the manifold along with some randomly sampled points + lying on the manifold. + + Parameters: + ----------- + n_samples : integer + The number of randomly sampled points. + + **scatter_kwargs: optional + Inherits the matplotlib scatter function parameters. + + Returns: + -------- + None. + + Notes: + ------ + This method internally calls the plot method. + """ + self.set_points(self.dist.random_point(n_samples=n_samples)) + self.plot() + if self.dim == 2: + + for point in self.points: + self.ax.scatter(point[0], point[1], **scatter_kwargs) + self.ax.set_title( + f"2 Dimension Categorical Manifold with {n_samples} Samples" + ) + elif self.dim == 3: + for point in self.points: + self.ax.scatter(point[0], point[1], point[2], **scatter_kwargs) + self.ax.set_title( + f"3 Dimension Categorical Manifold with {n_samples} Samples" + ) + + self.clear_points() + + def plot_geodesic(self, initial_point, end_point=None, + tangent_vector=None): + """Plot a geodesic on the manifold. + + Plot a geodesic that is either specified with + 1) an initial_point and an end_point, or + 2) an initial point and an initial tangent vector + on the manifold. + + Parameters: + ----------- + initial_point: array-like, shape = [..., dim + 1] + Initial point on the manifold. + + end_point: optional, array-like, shape = [..., dim + 1] + End point on the manifold. + + tangent_vector: optional, array-like, shape = [..., dim + 1] + Initial tangent vector at the initial point. + + Returns: + -------- + None. + + Notes: + ------ + Either end_point or tangent_vector needs to be specified. + The initial point will be marked red. + The initial tangent vector will also be plotted starting from + the initial point. + """ + self.plot() + geodesic = self.metric.geodesic( + initial_point=initial_point, + end_point=end_point, + initial_tangent_vec=tangent_vector, + ) + num_samples = 200 + if self.dim == 2: + for i in range(num_samples): + point = geodesic(i / num_samples) + self.ax.scatter(point[0], point[1], color="blue", s=2) + self.ax.scatter(geodesic(0)[0], geodesic(0)[1], + color="red", s=30) + if tangent_vector is not None: + normalized_tangent_vector = tangent_vector / np.sum( + np.power(tangent_vector, 2) + ) + self.ax.quiver( + initial_point[0], + initial_point[1], + normalized_tangent_vector[0], + normalized_tangent_vector[1], + color="red", + angles="xy", + scale_units="xy", + scale=10, + ) + else: + for i in range(num_samples): + point = geodesic(i / num_samples) + self.ax.scatter(point[0], point[1], point[2], color="blue", + s=2) + self.ax.scatter( + geodesic(0)[0], geodesic(0)[1], geodesic(0)[2], + color="red", s=30 + ) + if tangent_vector is not None: + normalized_tangent_vector = tangent_vector / ( + np.sum(np.power(tangent_vector, 2)) * 3 + ) + self.ax.quiver( + initial_point[0], + initial_point[1], + initial_point[2], + normalized_tangent_vector[0], + normalized_tangent_vector[1], + normalized_tangent_vector[2], + color="red", + # angles = 'xy', + # scale_units = 'xy', + # scale = 10, + ) + + def plot_log(self, end_point, base_point): + """Plot the result of taking the logarithm of two points on the manifold. + + Plot the tangent vector calculated from taking the logarithm between + the two input points on the manifold. + + Parameters: + ----------- + end_point: array-like, shape = [..., dim + 1] + End point on the manifold. + + base_point: array-like, shape = [..., dim + 1] + Base point on the manifold. + + Returns: + -------- + None. + """ + tangent_vec = self.metric.log(point=end_point, base_point=base_point) + self.plot_helper( + end_point=end_point, + base_point=base_point, + tangent_vec=tangent_vec, + operation="Log", + ) + + def plot_exp(self, tangent_vec, base_point): + """Plot the result of taking the exponential of one point with + one of its tangent vector. + + Plot the end point resulting from taking the exponential of the base + point with respect to a tangent vector. + + Parameters: + ----------- + tangent_vec: array-like, shape = [..., dim + 1] + A tangent vector at the base point. + + base_point: array-like, shape = [..., dim + 1] + Base point on the manifold. + + Returns: + -------- + None. + """ + end_point = self.metric.exp(tangent_vec=tangent_vec, + base_point=base_point) + self.plot_helper( + end_point=end_point, + base_point=base_point, + tangent_vec=tangent_vec, + operation="Exp", + ) + + def plot_helper(self, end_point, base_point, tangent_vec, operation): + """Plot two points and a vector together on a manifold. + + Helper function used by plot_exp and plot_log methods. + + Parameters: + ----------- + end_point: array-like, shape = [..., dim + 1] + End point on the manifold. + + base_point: array-like, shape = [..., dim + 1] + Base point on the manifold. + + tangent_vec: array-like, shape = [..., dim + 1] + A tangent vector to the manifold. + + Returns: + -------- + None. + + Notes: + ------ + The base point and the tangent vector will be marked red. + THe end point will be marked blue. + + """ + self.plot() + self.ax.set_title( + f"{operation} Operation with {self.dim} Dimension Categorical\ + Manifold" + ) + if self.dim == 3: + # Plot in Matplotlib + self.ax.scatter( + base_point[0], base_point[1], base_point[2], color="red", s=30 + ) + self.ax.scatter( + end_point[0], end_point[1], end_point[2], color="blue", s=30 + ) + self.ax.quiver( + base_point[0], + base_point[1], + base_point[2], + tangent_vec[0], + tangent_vec[1], + tangent_vec[2], + color="red", + length=0.1, + normalize=True, + ) + + if self.dim == 2: + self.ax.scatter(base_point[0], base_point[1], color="red", s=30) + self.ax.scatter(end_point[0], end_point[1], color="blue", s=30) + self.ax.quiver( + base_point[0], + base_point[1], + tangent_vec[0], + tangent_vec[1], + color="red", + angles="xy", + scale_units="xy", + scale=5, + ) + + def plot_grid(self): + """Plot the manifold with a geodesic grid. + + Plot some geodesic grid lines on top of a 2D manifold. + + Parameters: + ----------- + None. + + Returns: + -------- + None. + + Notes: + ------ + This function only works for 2D manifold. + """ + self.plot() + points = [ + np.array([0.5, 0, 0.5]), + np.array([0, 0.5, 0.5]), + np.array([0.5, 0.5, 0]), + np.array([0.25, 0, 0.75]), + np.array([0, 0.25, 0.75]), + np.array([0.75, 0, 0.25]), + np.array([0, 0.75, 0.25]), + ] + + num_samples = 100 + curves = [ + (0, 1), + (0, 2), + (1, 2), + (3, 2), + (4, 2), + (3, 4), + (5, 2), + (6, 2), + (5, 6), + ] + for curve in curves: + geodesic = self.metric.geodesic( + initial_point=points[curve[0]], end_point=points[curve[1]] + ) + for i in range(num_samples): + point = geodesic(i / num_samples) + self.ax.scatter(point[0], point[1], color="black", s=1) + + def clear_points(self): + """Clear the points stored in the object. + + Clear the points vector stored as an attribute of an object. + + Parameters: + ----------- + None. + + Returns: + -------- + None. + """ + self.points = [] + + def set_axis(self, min_limit, max_limit): + """Set the axes in 2D or 3D Euclidean space. + + Set the boundary of each axis for plotting + as specified in the input for plotting the manifold. + + Parameters: + ----------- + min_limit : float + Lower limit for each axis. + min_limit : float + Upper limit for each axis. + + Returns: + -------- + None. + + Notes: + ------ + This method is not intended to be called externally. + """ + if self.dim == 3: + ax = plt.subplot(111, projection="3d") + plt.setp( + ax, + xlim=(min_limit, max_limit), + ylim=(min_limit, max_limit), + zlim=(min_limit, max_limit), + anchor=(0, 0), + xlabel="X", + ylabel="Y", + zlabel="Z", + ) + + elif self.dim == 2: + ax = plt.subplot(111) + plt.setp( + ax, + xlim=(min_limit, max_limit), + ylim=(min_limit, max_limit), + xlabel="X", + ylabel="Y", + aspect="equal", + ) + + self.ax = ax + + def set_view(self, elev=30.0, azim=20.0): + """Set the viewing angle for plotting the 3D manifold. + + Set the elevation and azimuthal angle of viewing the 3D manifold. + + Parameters + ---------- + elev : float + Angle of elevation from the x-y plane in degrees (default: 30.0). + azim : float + Azimuthal angle in the x-y plane in degrees (default: 20.0). + + Returns + ------- + None. + """ + if self.dim == 3: + if self.ax is None: + self.set_axis() + self.elev, self.azim = elev, azim + self.ax.view_init(elev, azim) From d8e2950eaf225576898683731b96cfee19fb3f38 Mon Sep 17 00:00:00 2001 From: Ben Date: Mon, 30 Jan 2023 14:38:37 -0800 Subject: [PATCH 4/5] Add visualization for categorical distributions --- ...n_manifold_of_categorical_distributions.py | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py b/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py index 96e6d9158..188052d7f 100644 --- a/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py +++ b/tests/tests_geomstats/test_visualization_manifold_of_categorical_distributions.py @@ -1,48 +1,48 @@ """Unit tests for visualization.""" +import geomstats.visualization as visualization import matplotlib import matplotlib.pyplot as plt import numpy as np - -import geomstats.backend as gs -import geomstats.visualization as visualization import tests.conftest from CategoricalDistributionsManifold import CategoricalDistributionsManifold matplotlib.use("Agg") # NOQA -class TestVisualizationManifoldOfCategoricalDistributions(tests.conftest.TestCase): + +class TestVisualizationManifoldOfCategoricalDistributions( + tests.conftest.TestCase): def setup_method(self): self.n_samples = 10 self.CD2 = CategoricalDistributionsManifold(dim=2) self.CD3 = CategoricalDistributionsManifold(dim=3) plt.figure() - @staticmethod + @staticmethod def test_tutorial_matplotlib(): visualization.tutorial_matplotlib() - + def test_plot(self): self.CD2.plot() self.CD3.plot() - + def test_scatter(self): self.CD2.scatter(self.n_samples) self.CD3.scatter(self.n_samples) - + def test_plot_geodesic(self): - b2 = np.array([0.2,0.3,0.5]) - v2 = np.array([1,0,0]) + b2 = np.array([0.2, 0.3, 0.5]) + v2 = np.array([1, 0, 0]) self.CD2.plot_geodesic(initial_point=b2, tangent_vector=v2) - - b3 = np.array([0.3,0.3,0.2,0.2]) - v3 = np.array([1,0,0,0]) - self.CD3.plot_geodesic(initial_point = b3, tangent_vector =v3) - + + b3 = np.array([0.3, 0.3, 0.2, 0.2]) + v3 = np.array([1, 0, 0, 0]) + self.CD3.plot_geodesic(initial_point=b3, tangent_vector=v3) + def test_plot_grid(self): self.CD2.plot_grid() - + @staticmethod def teardown_method(): - plt.close() \ No newline at end of file + plt.close() From e1378c71167e542d7cc47925990f38686db28a68 Mon Sep 17 00:00:00 2001 From: Ben Date: Mon, 30 Jan 2023 23:35:50 -0800 Subject: [PATCH 5/5] Add notebook for categorical distributions manifold and their images. --- .../CategoricalDistributionsManifold.ipynb | 723 ++++++++++++++++++ notebooks/images/coins.png | Bin 0 -> 29015 bytes notebooks/images/color_naming.png | Bin 0 -> 388245 bytes notebooks/images/dice.jpeg | Bin 0 -> 41785 bytes notebooks/images/dome.jpeg | Bin 0 -> 94443 bytes notebooks/images/simplex.png | Bin 0 -> 34846 bytes 6 files changed, 723 insertions(+) create mode 100644 notebooks/CategoricalDistributionsManifold.ipynb create mode 100644 notebooks/images/coins.png create mode 100644 notebooks/images/color_naming.png create mode 100644 notebooks/images/dice.jpeg create mode 100644 notebooks/images/dome.jpeg create mode 100644 notebooks/images/simplex.png diff --git a/notebooks/CategoricalDistributionsManifold.ipynb b/notebooks/CategoricalDistributionsManifold.ipynb new file mode 100644 index 000000000..f36156c06 --- /dev/null +++ b/notebooks/CategoricalDistributionsManifold.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Manifolds for Categorical Distribution\n", + "Presented by: Steven Lin and Ian Wu\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + }, + "tags": [], + "toc-hr-collapsed": true + }, + "source": [ + "### What is a Categorical Distribution?\n", + "A Categorical distribution describes the results of a random variable that can take on one of $K$ categories for $K \\in \\mathbb{Z}_+$. \n", + "\n", + "Examples:\n", + "- Coin Flipping ($K=2$) - Two possible results: head and tail.\n", + "- Die Rolling ($K=6$) - Six possible results: 1, 2, 3, 4, 5, and 6.\n", + "
\n", + "

\n", + "

\n", + " \n", + "

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Probability 101\n", + "A probability of an event is a real number in the interval $[0,1]$ which describes how likely the event is going to happen. We denote the probability of an event as $P(E)$. $\\Omega$ usually denotes the sample space which consists of all possible events. Since all the events are inside, we must have $P(\\Omega)=1$.\n", + "\n", + "Examples:\n", + "1. A coin toss has two possible outcomes, namely head (H) or tail (T). The sample space is thus $\\Omega=\\{H,T\\}$. For a fair coin, one would expect that $P(H)=0.5=P(T)$. Suppose now we have an unfair coin which gives us tail $90\\%$ of the time, then the probability of us getting a head must be $P(H)=1-0.9=0.1$.\n", + "2. Since a die has six outcomes, we can write $\\Omega=\\{1,2,3,4,5,6\\}$. If our die is unfair, say the probability of getting $1,2,3,4$ or $5$ is $10\\%,20\\%,30\\%,30$ and $\\%10\\%$ respectively, then the probability of getting a $6$ must be $1-0.1-0.2-0.3-0.3-0.1=0$.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### The Manifold\n", + "- Notice that only $K-1$ probabilities are needed to characterize a $K$-category distribution; becaues all the probabilities must sum to 1, the last probability can be inferred by subtracting the sum of the $K-1$ probabilities from $1$.\n", + "- Another way of saying this is that the probabilites $P_i$, which all lie in the interval $[0,1]$, must satisfy the constraint $P_1+\\cdots+P_{K}=1$\n", + "- The resulting manifold is a **level set** that is known as the standard (k-1)-dimensional regular simplex for a k-category distribution.\n", + "- Definition for regular k-simplex:\n", + " $$\\Delta^k=\\{(x_1,\\cdots,x_{k+1})\\in\\mathbb{R}^{k+1}\\vert x_i\\geq 0 \\text{ for any }i \\text{ and }x_1+\\cdots+x_{k+1}=1\\}$$\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Shape of N-Dimensional Simplex\n", + "- A 0-D simplex is a point (Only one category with 100% Accuracy)\n", + "- A 1-D simplex is a line from 0 to 1 (Corresponding to the probability of one of the two events)\n", + "- A 2-D simplex is a triangle\n", + "- A 3-D simplex is a tetrahedron\n", + "- An n-D simplex is usually just called an n-simplex.\n", + "
\\\"default\\\"/
" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualization of the 2D and 3D Manifold\n", + "This function plots the regular $k$ simplex as long as $k=2$ or $3$. Note that, technically, a $k$ simplex lives in $\\mathbb{R}^{k+1}$ but this function plots the $k$ simplex in $\\mathbb{R}^k$. It does this by plotting the first $k$ coordinates in the simplex. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO: Using numpy backend\n" + ] + }, + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the Manifold with dimension 2 and 3\n", + "import CategoricalDistributionsManifold\n", + "import numpy as np\n", + "from importlib import reload \n", + "my_module = reload(CategoricalDistributionsManifold)\n", + "M2 = CategoricalDistributionsManifold.CategoricalDistributionsManifold(dim = 2)\n", + "M3 = CategoricalDistributionsManifold.CategoricalDistributionsManifold(dim = 3)\n", + "M2.plot()\n", + "M3.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualization of Random Samples over the Manifold" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " \n", + " " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the 2D and 3D manifold with random points\n", + "import CategoricalDistributionsManifold\n", + "my_module = reload(CategoricalDistributionsManifold)\n", + "M2.scatter(n_samples=5)\n", + "M3.scatter(n_samples=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Riemannian Metric on Manifolds of Categorical Distributions \n", + "We endow this manifold with the Fisher metric. More details can be found in this paper: Robert E. Kass. \"The Geometry of Asymptotic Inference.\" Statist. Sci. 4 (3) 188 - 219, August, 1989. https://doi.org/10.1214/ss/1177012480" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualization of Exp\n", + "Given an initial point and an initial tangent vector, the function gives the output of the exponential function. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Visualization of Exp\n", + "#%matplotlib widget\n", + "from geomstats.information_geometry.categorical import CategoricalDistributions, CategoricalMetric\n", + "dist2 = CategoricalDistributions(dim = 2)\n", + "vector2 = np.array([1,0,0])\n", + "base_point2 = np.array([0.3, 0.3, 0.4])\n", + "tangent_vector2 = dist2.to_tangent(vector = vector2, base_point= base_point2)\n", + "\n", + "M2.plot_exp(tangent_vec = tangent_vector2, base_point = base_point2)\n", + "\n", + "dist3 = CategoricalDistributions(dim = 3)\n", + "vector3 = np.array([1,0,0,0])\n", + "base_point3 = np.array([0.3, 0.3, 0.2, 0.2])\n", + "tangent_vector3 = dist3.to_tangent(vector = vector3, base_point= base_point3)\n", + "\n", + "M3.plot_exp(tangent_vec = tangent_vector3, base_point = base_point3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualization of Geodesics with Initial and End Points Specified\n", + "This function plots the geodesic on the manifold with respect to the Fisher metric. Notice that geodesics are not straight lines because the metric is not the Euclidean Metric." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAHFCAYAAABsA4m6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6NElEQVR4nO3de1xUdcLH8S+CgKhgaCKK4uVJJDVNfDRxzU2NUtesbHVzy0v6vHKtTLE2zfJWG2nbTVO3i5etNddKazXNpDXNki4amqmrpSZeUAMT0RQcOM8fLqPDDDDAzJy5fN6vF6/dOZwZfnPC+XDO+Z2ZIMMwDAEAEOBqmD0AAAC8AUEEAEAEEQAASQQRAABJBBEAAEkEEQAASQQRAABJBBEAAEkEEQAASQTRp2zYsEH33Xef2rRpo9q1a6tJkyYaOHCgtm3b5tT9p0+frqCgIOtXRESE4uLidMstt2ju3LnKz8+3u8+IESPUvHlzFz8Tz/vpp58UFBSkJUuWmDaGzZs3a/DgwWrSpIlCQ0MVFRWl5ORkLViwQOfOnav047399tt66aWXXD9QN9m4caOCgoK0ceNGtzy+s/+NS9YLCgrS9OnTHa5z3333WddxN0fj+Pe//63OnTurdu3aCgoK0gcffOD041VmO/vLv29XIYg+ZMGCBfrpp5/08MMPa+3atXr55Zd18uRJ3XDDDdqwYYPTj7Nu3TplZGRo3bp1+utf/6pmzZrpz3/+s9q2basdO3bYrPvkk0/q/fffd/VT8bjY2FhlZGSof//+pvz8adOm6cYbb9TRo0f11FNPKT09Xf/85z/Vu3dvTZ8+XU888USlH9PXgtipUydlZGSoU6dOZg9FklS3bl0tWbJExcXFNsvPnj2rd999V5GRkR4ZR0ZGhkaPHm29bRiGBg8erJo1a2rVqlXKyMhQz549PTKWgGfAZ5w4ccJuWX5+vhETE2P07t27wvtPmzbNkGT8/PPPdt/bvn27ERUVZTRr1sy4cOGCS8aLS9555x1DkjFq1CijuLjY7vtnzpwxPv7440o/bv/+/Y34+HgXjNC9CgsLjYsXL7r95xw8eNCQZCxevNip9UaPHm1IMtavX2/z/TfeeMOoVauWcc899xhmvEQeOXLEkGTMmjWrSvf/9NNPDUnGp59+WuG6w4cP94nfIU9hD9GHNGzY0G5ZnTp1dO211+rw4cPVeuwOHTpoypQpysrK0vLly63LHR1SCQoK0oMPPqjFixcrISFBtWrVUufOnfXll1/KMAw999xzatGiherUqaNevXrpxx9/tPt5n3zyiXr37q3IyEhFRESoe/fu+ve//22zTskh3l27dunuu+9WVFSUYmJidN999ykvL89m3XfffVddu3ZVVFSUIiIi1LJlS913333W75d1OO3zzz9X7969VbduXUVERCg5OVlr1qyxWWfJkiUKCgrSp59+qj/96U9q0KCB6tevrzvvvFPHjh2rcNvOnDlTV111lebMmePwEFzdunWVkpJivT1v3jzdeOONatiwoWrXrq327dtr9uzZunjxonWd3/72t1qzZo0OHTpkcxi8RGFhoZ5++mm1adNGYWFhuvrqqzVy5Ej9/PPPNj+7oKBAEydOVKNGjRQREaEbb7xR27ZtU/PmzTVixAibdb///nsNHDhQV111lcLDw9WxY0f9/e9/t1mn5HDdW2+9pYkTJ6pJkyYKCwvTjz/+WOahvK+++koDBgxQ/fr1FR4erlatWmn8+PHW7//4448aOXKkrrnmGkVERKhJkyYaMGCAdu7cWeG2L09CQoKSk5O1aNEim+WLFi3SnXfeqaioKLv7LF++XCkpKYqNjVWtWrWUmJioSZMm2R3yHjFihOrUqaMff/xR/fr1U506ddS0aVNNnDhRBQUFNuteech0+vTpiouLkyQ99thjCgoKsvn358zva1mWLFmihIQEhYWFKTExUW+++aZT9wskBNHH5eXl6dtvv1Xbtm2r/Vi33XabJOmzzz6rcN0PP/xQb7zxhp599lktW7ZM+fn56t+/vyZOnKgvvvhCr7zyil577TXt3r1bgwYNknHFh6r84x//UEpKiiIjI/X3v/9d77zzjqKjo3XLLbfYRVGSBg0apNatW2vFihWaNGmS3n77bU2YMMH6/YyMDA0ZMkQtW7bUP//5T61Zs0ZTp06VxWIp9zls2rRJvXr1Ul5enhYuXKhly5apbt26GjBggM0fBSVGjx6tmjVr6u2339bs2bO1ceNG3XPPPeX+jOzsbH3//fdKSUlRRERERZtVkrR//34NHTpUb731lj788EONGjVKzz33nO6//37rOvPnz1f37t3VqFEjZWRkWL8kqbi4WAMHDtSzzz6roUOHas2aNXr22WeVnp6u3/72tzp//rz1cUaOHKmXXnpJI0eO1L/+9S8NGjRId9xxh06fPm0zpr179yo5OVm7du3SnDlztHLlSl177bUaMWKEZs+ebfccJk+erKysLP3tb3/T6tWrHf4xJ0kff/yxevTooaysLL3wwgv66KOP9MQTT+jEiRPWdY4dO6b69evr2Wef1bp16zRv3jyFhISoa9eu2rt3r1PbtCyjRo3SBx98oF9++cX6PLds2aJRo0Y5XP+HH35Qv379tHDhQq1bt07jx4/XO++8owEDBtite/HiRd12223q3bu3/vWvf+m+++7Tiy++qFmzZpU5ntGjR2vlypWSpIceekgZGRnWUxaV/X290pIlSzRy5EglJiZqxYoVeuKJJ/TUU09V6lRLQDB7FxXV88c//tEICQkxtm7dWuG65R0yNQzDOH/+vCHJ6Nu3r3WZo0MqkoxGjRoZZ8+etS774IMPDElGx44dbQ4LvvTSS4Yk47vvvjMMwzDOnTtnREdHGwMGDLB5zKKiIqNDhw5Gly5d7MY7e/Zsm3XHjh1rhIeHW3/OX//6V0OScfr06TKfu6PDaTfccIPRsGFDIz8/37rMYrEY7dq1M+Li4qyPv3jxYkOSMXbsWJvHnD17tiHJyM7OLvPnfvnll4YkY9KkSWWuU56ioiLj4sWLxptvvmkEBwcbp06dsn6vrEOmy5YtMyQZK1assFn+zTffGJKM+fPnG4ZhGLt27TIkGY899pjD+w8fPty67A9/+IMRFhZmZGVl2azbt29fIyIiwrrtSw7X3XjjjXbjcnQor1WrVkarVq2M8+fPO7U9DOPSf6PCwkLjmmuuMSZMmGBdXtlDps8995yRn59v1KlTx3jllVcMwzCMRx991GjRooVRXFxsPPDAA+UeMi0uLjYuXrxobNq0yZBk7Nixw/q94cOHG5KMd955x+Y+/fr1MxISEmyWSTKmTZvmcHxXcvb3tfR2LioqMho3bmx06tTJ5t/mTz/9ZNSsWZNDpldgD9GHPfnkk1q6dKlefPFFJSUlVfvxjEp8NOZNN92k2rVrW28nJiZKkvr27Wtz6K5k+aFDhyRJW7Zs0alTpzR8+HBZLBbrV3FxsW699VZ98803doefSvZcS1x33XW6cOGCTp48KUn63//9X0nS4MGD9c477+jo0aMVjv/cuXP66quvdNddd6lOnTrW5cHBwbr33nt15MgRu70PR+O48rm5SmZmpm677TbVr19fwcHBqlmzpoYNG6aioiLt27evwvt/+OGHqlevngYMGGCzjTt27KhGjRpZD1lu2rRJ0qXtdqW77rpLISEhNss2bNig3r17q2nTpjbLR4wYoV9//dW6d1pi0KBBFY5z37592r9/v0aNGqXw8PAy17NYLHrmmWd07bXXKjQ0VCEhIQoNDdUPP/ygPXv2VPhzylOnTh39/ve/16JFi2SxWPTmm29q5MiRZc4uPXDggIYOHapGjRpZ/9uUTHgpPZagoCC7PcfrrruuSr8vVfl9LbF3714dO3ZMQ4cOtXle8fHxSk5OrvRY/FlIxavAG82YMUNPP/20/vKXv+jBBx90yWOW/ENt3LhxhetGR0fb3A4NDS13+YULFyTJeijsrrvuKvOxT506ZRPb+vXr23w/LCxMkqyH/m688UZ98MEHmjNnjoYNG6aCggK1bdtWU6ZM0d133+3wZ/zyyy8yDEOxsbF23yt5/rm5uTbLKxqHI82aNZMkHTx4sMx1rpSVlaUePXooISFBL7/8spo3b67w8HB9/fXXeuCBB8r9WSVOnDih06dPW7d9aTk5OZIuP7+YmBib74eEhNg919zc3EptK0frllZyPrPknFlZUlNTNW/ePD322GPq2bOnrrrqKtWoUUOjR492antUZNSoUfrNb36jv/zlL/r555/tzp2WOHv2rHr06KHw8HA9/fTTat26tSIiInT48GHdeeeddmOJiIiwC31YWJj130JlVOX3tUTJ8kaNGtl9r1GjRvrpp58qPR5/RRB90IwZMzR9+nRNnz5djz/+uMsed9WqVZIuTdhwlwYNGkiS5s6dqxtuuMHhOqVfoJ0xcOBADRw4UAUFBfryyy+VlpamoUOHqnnz5urWrZvd+iUvqtnZ2XbfK5koUzLW6oiNjVX79u21fv16/frrrxWeR/zggw907tw5rVy5UvHx8dbl27dvd/pnlkz6WbduncPv161bV9LlwJ84cUJNmjSxft9isTj8Y6Ay28qZ6/euvvpqSdKRI0fKXe8f//iHhg0bpmeeecZmeU5OjurVq1fhz6lI9+7dlZCQoJkzZ+rmm2+22wsusWHDBh07dkwbN260uQyi9PlWd6jO72vJf+fjx4/bfc/RskDGIVMf89RTT1mvW5s2bZrLHnfHjh165pln1Lx5c7tDaK7UvXt31atXT7t371bnzp0dfpW1Z+OMsLAw9ezZ0zpxITMz0+F6tWvXVteuXbVy5Uqbv+yLi4v1j3/8Q3FxcWrdunWVx3GlJ598Ur/88ovGjRvn8LD02bNntX79ekmXQ1Ky9yldOpT9+uuv290vLCzM4R7S7373O+Xm5qqoqMjh9k1ISJB0ac9akt2EjPfee89uQlLv3r2tQbjSm2++qYiIiDL/uClP69at1apVKy1atMhu5uWVgoKCbLaHJK1Zs8apQ+POeuKJJzRgwABNnDix3HFIshvLq6++6rJxlKU6v68JCQmKjY3VsmXLbH7/Dh06pC1btrh97L6EPUQf8vzzz2vq1Km69dZb1b9/f3355Zc233f2RWnbtm2KiorSxYsXdezYMf373//WW2+9pYYNG2r16tXVClJF6tSpo7lz52r48OE6deqU7rrrLjVs2FA///yzduzYoZ9//lkLFiyo1GNOnTpVR44cUe/evRUXF6fTp0/r5Zdftjm/40haWppuvvlm3XTTTXrkkUcUGhqq+fPn6/vvv9eyZctc9i4lv//97/Xkk0/qqaee0n/+8x+NGjVKrVq10q+//qqvvvpKr776qoYMGaKUlBTdfPPNCg0N1d13360///nPunDhghYsWGCdBXml9u3ba+XKlVqwYIGSkpJUo0YNde7cWX/4wx+0dOlS9evXTw8//LC6dOmimjVr6siRI/r00081cOBA3XHHHWrbtq3uvvtuPf/88woODlavXr20a9cuPf/884qKilKNGpf/Xp42bZo+/PBD3XTTTZo6daqio6O1dOlSrVmzRrNnz3Z4iYIz5s2bpwEDBuiGG27QhAkT1KxZM2VlZenjjz/W0qVLJV0K/JIlS9SmTRtdd9112rZtm5577rkKD7VWxj333FPhjOHk5GRdddVVGjNmjKZNm6aaNWtq6dKldm9m4S5V/X2tUaOGnnrqKY0ePVp33HGH/u///k+nT5/W9OnTHR5GDWQE0YesXr1a0qV3mnF0OMzZSTG33nqrpEt/6UZHR6t9+/aaNWuWRo4caT2c5k733HOPmjVrptmzZ+v+++9Xfn6+GjZsqI4dO5Z5/qY8Xbt21datW/XYY4/p559/Vr169dS5c2dt2LCh3MtRevbsqQ0bNmjatGkaMWKEiouL1aFDB61atUq/+93vqvEM7c2cOVN9+vTR3LlzNWXKFOXk5KhWrVpq27atUlNTrZdUtGnTxjot/s4771T9+vU1dOhQpaamqm/fvjaP+fDDD2vXrl16/PHHlZeXJ8MwZBiGgoODtWrVKr388st66623lJaWppCQEMXFxalnz55q37699TEWL16s2NhYLVy4UC+++KI6duyod955R7feeqvN4ciEhARt2bJFjz/+uPVcZmJiohYvXlyl/2YlbrnlFn322WeaOXOmxo0bpwsXLiguLs5mAlPJHzdpaWk6e/asOnXqpJUrV1bp3X2qo379+lqzZo0mTpyoe+65R7Vr19bAgQO1fPlyj7z7TnV+X0suI5k1a5buvPNONW/eXI8//rg2bdrktrfS80VBRmWmFgLwe1u2bFH37t21dOlSDR061OzhAB5DEIEAlp6eroyMDCUlJalWrVrasWOHnn32WUVFRem7774r93IIwN9wyBQIYJGRkVq/fr1eeukl5efnq0GDBurbt6/S0tKIIQIOe4gAAMjkyy4+++wzDRgwQI0bN3b6M782bdqkpKQkhYeHq2XLlvrb3/7m/oECAPyeqUE8d+6cOnTooFdeecWp9Q8ePKh+/fqpR48eyszM1OOPP65x48ZpxYoVbh4pAMDfec0h06CgIL3//vu6/fbby1znscce06pVq2zeM3DMmDHasWOH3XspAgBQGT41qSYjI8Pmc+OkS9cxLVy4UBcvXlTNmjXt7lNQUGDzLhjFxcU6deqU6tev77ILrwEAnmMYhvLz89W4cWObN5CoLp8K4vHjx+3e5zImJkYWi0U5OTkO3/g2LS1NM2bM8NQQAQAecvjwYZe+Y5FPBVGyf9PgkiO+Ze3tTZ48WampqdbbeXl5atasmbZt26bo6GhdddVV7CkCgA85c+aMmjZt6vJ31vKpIDZq1Mju3dlPnjzp8ONqSoSFhdm9Ga906T01w8LCZLFYFB0dTRQBwMe4+nXbpz7tolu3bkpPT7dZtn79enXu3Nnh+UNnFBYW6tSpU5X6cFwAgP8xNYhnz57V9u3brZ/1dvDgQW3fvl1ZWVmSLh3uHDZsmHX9MWPG6NChQ0pNTdWePXu0aNEiLVy4UI888ki1xkEUAQCmBnHr1q26/vrrdf3110u69MnY119/vaZOnSpJys7OtsZRklq0aKG1a9dq48aN6tixo5566inNmTNHgwYNqvZYiCIABDavuQ7RU86cOaOoqCjt3bvX4QnZ0NBQzikCgBcreR3Py8tTZGSkyx7Xp84hegJ7igAQmAiiA0QRAAIPQSwDUQSAwEIQy0EUASBwEMQKEEUACAwE0QlEEQD8H0F0ElEEAP9GECuBKAKA/yKIlUQUAcA/EcQqIIoA4H8IYhURRQDwLwSxGogiAPgPglhNRBEA/ANBdAGiCAC+jyC6CFEEAN9GEF2IKAKA7yKILkYUAcA3EUQ3IIoA4HsIopsQRQDwLQTRjYgiAPgOguhmRBEAfANB9ACiCADejyB6CFEEAO9GED2IKAKA9yKIHkYUAcA7EUQTEEUA8D4E0SREEQC8C0E0EVEEAO9BEE1GFAHAOxBEL0AUAcB8BNFLEEUAMBdB9CJEEQDMQxC9DFEEAHMQRC9EFAHA8wiilyKKAOBZBNGLEUUA8ByC6OWIIgB4BkH0AUQRANyPIPoIoggA7kUQfQhRBAD3IYg+higCgHsQRB9EFAHA9QiijyKKAOBaBNGHEUUAcB2C6OOIIgC4BkH0A0QRAKqPIPoJoggA1UMQ/QhRBICqI4h+higCQNUQRD9EFAGg8giinyKKAFA5BNGPEUUAcB5B9HNEEQCcQxADAFEEgIoRxABBFAGgfAQxgBBFACgbQQwwRBEAHCOIAYgoAoA9ghigiCIA2CKIAYwoAsBlBDHAEUUAuIQggigCgAgi/osoAgh0pgdx/vz5atGihcLDw5WUlKTNmzeXu/7SpUvVoUMHRUREKDY2ViNHjlRubq6HRuvfiCKAQGZqEJcvX67x48drypQpyszMVI8ePdS3b19lZWU5XP/zzz/XsGHDNGrUKO3atUvvvvuuvvnmG40ePdrDI/dfRBFAoDI1iC+88IJGjRql0aNHKzExUS+99JKaNm2qBQsWOFz/yy+/VPPmzTVu3Di1aNFCv/nNb3T//fdr69atHh65fyOKAAKRaUEsLCzUtm3blJKSYrM8JSVFW7ZscXif5ORkHTlyRGvXrpVhGDpx4oTee+899e/fv8yfU1BQoDNnzth8oWJEEUCgMS2IOTk5KioqUkxMjM3ymJgYHT9+3OF9kpOTtXTpUg0ZMkShoaFq1KiR6tWrp7lz55b5c9LS0hQVFWX9atq0qUufhz8jigACiemTaoKCgmxuG4Zht6zE7t27NW7cOE2dOlXbtm3TunXrdPDgQY0ZM6bMx588ebLy8vKsX4cPH3bp+P0dUQQQKELM+sENGjRQcHCw3d7gyZMn7fYaS6Slpal79+569NFHJUnXXXedateurR49eujpp59WbGys3X3CwsIUFhbm+icQQEqiGB0dXeYfKwDg60zbQwwNDVVSUpLS09Ntlqenpys5OdnhfX799VfVqGE75ODgYEliD8bN2FME4O9MPWSampqqN954Q4sWLdKePXs0YcIEZWVlWQ+BTp48WcOGDbOuP2DAAK1cuVILFizQgQMH9MUXX2jcuHHq0qWLGjdubNbTCBhEEYA/M+2QqSQNGTJEubm5mjlzprKzs9WuXTutXbtW8fHxkqTs7GybaxJHjBih/Px8vfLKK5o4caLq1aunXr16adasWWY9hYDD4VMA/irICLA/98+cOaOoqCjt3btXdevWNXs4Pis0NJQoAjBFyet4Xl6eIiMjXfa4ps8yhW/i8CkAf0MQUWVEEYA/IYioFqIIwF8QRFQbUQTgDwgiXIIoAvB1BBEuQxQB+DKCCJciigB8FUGEyxFFAL6IIMItiCIAX0MQ4TZEEYAvIYhwK6IIwFcQRLgdUQTgCwgiPIIoAvB2BBEeQxQBeDOCCI8iigC8FUGExxFFAN6IIMIURBGAtyGIMA1RBOBNCCJMRRQBeAuCCNMRRQDegCDCKxBFAGYjiPAaRBGAmQgivApRBGAWggivQxQBmIEgwisRRQCeFmL2AOD7Qho3Vn1JQVcsMyTlSrIcO1blxy2JYnR0tIKCgiq+AwBUA3uIqJaQxo3VQJdiWPqrwX+/Xx3sKQLwFIKIaqn/3/8tvf8WVOr71UEUAXgCQUS1lOwNlvd9VyCKANyNIMJtXH3WjygCcCeCCLdxR7aIIgB3IYioFkPlh48oAvAVBBHVkvvf/70yjFf+/1y7e7gGUQTgagQR1WI5dkw5so1hyf/mqHrXIVaEKAJwJYKIarMcO6YTx45pwycnVEOGashQsAx998kJt/9sogjAVQgiXKaoqPzb7kIUAbgCQYTLZGcHl3vbnYgigOoiiHCZ2FjbXcKGDT20i/hfRBFAdRBEuExYmO3t8eOvksXi2TEQRQBVRRDhMi1bFql160Lr7X37amr/fs8dNi1BFAFUBUGEy4SESHPnnrZZ5qmJNaURRQCVRRDhUsGe3yEsE1EEUBkEEX6NKAJwFkGE3yOKAJxBEBEQiCKAihBEBAyiCKA8BBEBhSgCKAtBhEuFhJg9gooRRQCOEES4VMuWRWrf/vLF+RMm1PP4u9U4gygCKI0gwqVCQqQXXzxtvb1zZ6gp71bjDKII4EoEEW5n1rvVOIMoAihBEBHwiCIAiSACkogiAIIIWBFFILARROAKRBEIXAQRKIUoAoGJIAIOEEUg8BBEoAxEEQgsBBEoB1EEAgdBBCpAFIHAQBDhcqXf4NsX3vC7IkQR8H8EES7XrFmRwsOLJUnh4cVq1syL37utEogi4N8IIlzu0KFgXbhw6VfrwoUaOnTIO9/cuyqIIuC/TA/i/Pnz1aJFC4WHhyspKUmbN28ud/2CggJNmTJF8fHxCgsLU6tWrbRo0SIPjRbOKP1m3oWFjtfzVUQR8E+mnt1Zvny5xo8fr/nz56t79+569dVX1bdvX+3evVvNmjVzeJ/BgwfrxIkTWrhwof7nf/5HJ0+elMUbP3AvgJU+Z/jQQ1fpk09y/OJcYomSKEZHRysoKMjs4QBwgSDDxD9zu3btqk6dOmnBggXWZYmJibr99tuVlpZmt/66dev0hz/8QQcOHFB0dHSVfuaZM2cUFRWlvXv3qm7dulUeO8pmsUh9+tTXvn2h1mWffnpSCQn+cS7xSqGhoUQR8LCS1/G8vDxFRka67HFNO2RaWFiobdu2KSUlxWZ5SkqKtmzZ4vA+q1atUufOnTV79mw1adJErVu31iOPPKLz58+X+XMKCgp05swZmy+4V0iINHfuaZtl3vyZiNXB4VPAf5h2ECsnJ0dFRUWKiYmxWR4TE6Pjx487vM+BAwf0+eefKzw8XO+//75ycnI0duxYnTp1qszziGlpaZoxY4bLx4/yBfvPPJoKcfgU8A+mT6op/QJiGEaZLyrFxcUKCgrS0qVL1aVLF/Xr108vvPCClixZUuZe4uTJk5WXl2f9Onz4sMufA8CeIuD7TAtigwYNFBwcbLc3ePLkSbu9xhKxsbFq0qSJoqKirMsSExNlGIaOHDni8D5hYWGKjIy0+YL7+ePF+RUhioBvMy2IoaGhSkpKUnp6us3y9PR0JScnO7xP9+7ddezYMZ09e9a6bN++fapRo4bi4uLcOl5Ujr9enF8Rogj4LlMPmaampuqNN97QokWLtGfPHk2YMEFZWVkaM2aMpEuHO4cNG2Zdf+jQoapfv75Gjhyp3bt367PPPtOjjz6q++67T7Vq1TLracABf744vyJEEfBNph7IGjJkiHJzczVz5kxlZ2erXbt2Wrt2reLj4yVJ2dnZysrKsq5fp04dpaen66GHHlLnzp1Vv359DR48WE8//bRZTwFlKD2r1F9nmZaFiTaA7zH1OkQzcB2iZ+zeHaw+fRpab3/yyUlde22AVVFcpwi4g99dhwgEAg6fAr6DIMItAnGWaVmIIuAbCCLcIlBnmZaFKALejyDCLQJ5lmlZiCLg3Qgi3CLQZ5mWhSgC3osgAh5GFAHvRBABExBFwPsQRMAkRBHwLgQRbsFlF84hioD3IIhwCy67cB5RBLwDQYRbcNlF5RBFwHwEEW7BZReVRxQBcxFEwIsQRcA8BBFuwaSaqiOKgDkIItyCSTXVQxQBzyOIcAsm1VQfUQQ8iyDCLZhU4xpEEfAcggh4OaIIeAZBhFswqca1iCLgfgQRbtG4cZHCwi5NqqlVi0k1rkAUAfciiHA5i0UaMKCBCgou/XqdP19DR48yqcYViCLgPgQRLrd/f7D27q1pvZ2QUKj4ePYQXYUoAu5BEOFypWeUzplzmnOILkYUAdcjiHC7YI6WugVRBFyLIMLlmGHqOUQRcB2ng3jkyBF3jgN+hLdt8yyiCLiG00Fs166d3nrrLXeOBX6Ct23zPKIIVJ/TQXzmmWf0wAMPaNCgQcrNzXXnmODjeNs2cxBFoHqcDuLYsWO1Y8cO/fLLL2rbtq1WrVrlznHBh3EO0TxEEai6Sr1UtWjRQhs2bNArr7yiQYMGKTExUSGlXu2+/fZblw4QvqfkHOKFCzU4h2iCkihGR0crKCjI7OEAPqPSf7sfOnRIK1asUHR0tAYOHGgXRMDROcSEBKLoSUQRqLxK1ez111/XxIkT1adPH33//fe6+uqr3TUu+DDOIXoHoghUjtNBvPXWW/X111/rlVde0bBhw9w5JgAuQhQB5zkdxKKiIn333XeKi4tz53jgB5hU412IIuAcp1+q0tPT3TkO+BEm1XgfoghUjLdug8txYb534pIMoHwEES7HpBrvRRSBshFEIMAQRcAxggi3Y1KN9yGKgD2CCJeyWKQJE+pZb7dvX6iWLTlm6o2IImCLIMKl9u8P1s6dodbbL754mj1EL0YUgcsIIlyKCTS+hygClxBEuBQX5fsmoggQRLhYyUX5krgo38cQRQQ6ggiX4qJ830YUEcgIIlyKi/J9H1FEoCKIAOwQRQQiggiXYlKN/yCKCDQEES7FpBr/QhQRSAgiXOrAASbV+BuiiEBBEOEyFov0wANX2Szjo/f8A1FEICCIcJlDh4K1d29N6+2EBN7H1J8QRfg7ggiXadLk8vnDsLBirV6dy6QaP0MU4c8IIlzmyovyCwpq6OhRzh/6I6IIf0UQ4TJclB84iCL8EUEEUCVEEf6GIMJluCg/8BBF+BOCCJfhovzARBThLwgiXIZPughcRBH+gCDCZZhUE9iIInwdQYTbcA4x8BBF+DKCCJewWKQJE+pZb7dvz7vUBCqiCF9FEOES+/cHa+fOUOvtF188zR5iACOK8EWmB3H+/Plq0aKFwsPDlZSUpM2bNzt1vy+++EIhISHq2LGjewcIp3C+EKURRfgaU4O4fPlyjR8/XlOmTFFmZqZ69Oihvn37Kisrq9z75eXladiwYerdu7eHRoqKcA0iHCGK8CWmBvGFF17QqFGjNHr0aCUmJuqll15S06ZNtWDBgnLvd//992vo0KHq1q2bh0aKinANIspCFOErTAtiYWGhtm3bppSUFJvlKSkp2rJlS5n3W7x4sfbv369p06Y59XMKCgp05swZmy+4HtcgojxEEb7AtCDm5OSoqKhIMTExNstjYmJ0/Phxh/f54YcfNGnSJC1dulQhTh6TS0tLU1RUlPWradOm1R477BUW2t7mnCJKI4rwdqZPqgkq9ZHqhmHYLZOkoqIiDR06VDNmzFDr1q2dfvzJkycrLy/P+nX48OFqjxm2LBZp3LirbJZxDhGOEEV4M9Netho0aKDg4GC7vcGTJ0/a7TVKUn5+vrZu3arMzEw9+OCDkqTi4mIZhqGQkBCtX79evXr1srtfWFiYwsLC3PMkIOnS4dK9e2tabyckcA0iylYSxejoaId//AJmMW0PMTQ0VElJSUpPT7dZnp6eruTkZLv1IyMjtXPnTm3fvt36NWbMGCUkJGj79u3q2rWrp4aOUpo0uTyhJiysWKtX57KHiHKxpwhvZOrLVmpqqu6991517txZ3bp102uvvaasrCyNGTNG0qXDnUePHtWbb76pGjVqqF27djb3b9iwocLDw+2Ww7OunFBTUFBDR48GKyGBPUSUjz1FeBtTgzhkyBDl5uZq5syZys7OVrt27bR27VrFx8dLkrKzsyu8JhHm4029UVVEEd4kyAiwYxZnzpxRVFSU9u7dq7p165o9HL+wb1+wfvvbhtbbGzeeVOvWVBHOCw0NJYpwWsnreF5eniIjI132uKbPMoXv46J8VBfnFOENCCKq7cABLspH9RFFmI0golosFumBB2yvQeSoF6qKKMJMBBHVwjWIcDWiCLMQRFQL1yDCHYgizEAQUS2OrkEEXIEowtMIIqqFaxDhTkQRnkQQAXg1oghPIYhwKc4fwh2IIjyBIKLKLBZpwoR61tvt2zPDFO5DFOFuBBFVtn9/sHbuDLXefvHF0+whwq2IItyJIKLKmEADMxBFuAtBRJWV3htk7xCeQhThDgQRVcabesNMRBGuRhBRZbypN8xGFOFKBBFVYrFIY8fypt4wH1GEqxBEVMn+/cHat+/ym3q3bs0lFzAPUYQrEERUSem9wfnzueQC5iKKqC6CiCopPaGGvUN4A6KI6iCIqJIrP+WCCTXwJkQRVUUQUSWFhba3uUgf3oQooioIIirNYpHGjbOdYcr5Q3gboojKIoiotEOHgrV37+UZpgkJzDCFdyKKqAyCiEpr0uTyhJqwsGKtXp3LHiK8FlGEswgiKu3KCTUFBTV09CgTauDdiCKcQRBRaUyogS8iiqgIQUSlMKEGvowoojwEEZXChBr4OqKIshBEVAoTauAPiCIcIYioFCbUwF8QRZRGEFEpTKiBPyGKuBJBhNOYUAN/RBRRgiDCaUyogb8iipAIIiqBCTXwZ0QRBBFOY0IN/B1RDGwEEU5jQg0CAVEMXAQRTmFCDQIJUQxMBBFOYUINAg1RDDwEEU5hQg0CEVEMLAQRTmFCDQIVUQwcBBFOYUINAhlRDAwEERViQg1AFAMBQUSFmFADXEIU/RtBRIWYUANcRhT9F0FEhZhQA9giiv6JIKJCTKgB7BFF/0MQUS6LRXroISbUAI4QRf9CEFGu/fuDtW/f5Qk1rVszoQa4ElH0HwQR5QoKsr09f/5p9hCBUoiifyCIKFezZpdnmIaHF7N3CJSBKPo+gohyHThweYbphQs1dOgQM0yBshBF30YQUSaLRRo71nZCTelDqABsEUXfRRBRJibUAFVDFH0TQUSZSl9/OHcuE2oAZxFF30MQ4ZCjN/QOCzNpMICPIoq+hSDCId7QG3ANoug7CCIc4g29Adchir6BIMKhKy+34A29geojit6PIMIOl1sA7kEUvRtBhB0utwDchyh6L4IIO6U/3onLLQDXIoreiSCiQsGcPgRcjih6H4KICrF3CLgHUfQupgdx/vz5atGihcLDw5WUlKTNmzeXue7KlSt188036+qrr1ZkZKS6deumjz/+2IOj9X8WizRhQj3r7fbtOX8IuBNR9B6mBnH58uUaP368pkyZoszMTPXo0UN9+/ZVVlaWw/U/++wz3XzzzVq7dq22bdumm266SQMGDFBmZqaHR+6/9u8P1s6dodbbL77I+UPA3YiidwgyTPwv0LVrV3Xq1EkLFiywLktMTNTtt9+utLQ0px6jbdu2GjJkiKZOnerU+mfOnFFUVJT27t2runXrVmnc/mznzmDdcktD6+1PPjmpa69lDxHwhNDQUEVHRyuI65zKVfI6npeXp8jISJc9rml7iIWFhdq2bZtSUlJslqekpGjLli1OPUZxcbHy8/MVHR1d5joFBQU6c+aMzRccs1ikhx6yvf6QvUPAc9hTNJdpQczJyVFRUZFiYmJslsfExOj48eNOPcbzzz+vc+fOafDgwWWuk5aWpqioKOtX06ZNqzVuf8b1h4D5iKJ5TJ9UU/rQgGEYTh0uWLZsmaZPn67ly5erYcOGZa43efJk5eXlWb8OHz5c7TH7Kz7uCfAORNEcpr3cNWjQQMHBwXZ7gydPnrTbayxt+fLlGjVqlN5991316dOn3HXDwsIUxucWVcjR4VI2G2CekihyTtFzTNtDDA0NVVJSktLT022Wp6enKzk5ucz7LVu2TCNGjNDbb7+t/v37u3uYAYPDpYD3YU/Rs0w9IJaamqp7771XnTt3Vrdu3fTaa68pKytLY8aMkXTpcOfRo0f15ptvSroUw2HDhunll1/WDTfcYN27rFWrlqKiokx7Hv6Aw6WAd2JP0XNMfckbMmSIcnNzNXPmTGVnZ6tdu3Zau3at4uPjJUnZ2dk21yS++uqrslgseuCBB/TAAw9Ylw8fPlxLlizx9PD9hsUijRvH4VLAWxFFzzD1OkQzcB2ivf37g9Wjx+WJSQkJhUpP5wOBAW/DdYqX+N11iPAeTZoUKTy8WJIUFlas1auJIeCNOKfoXgQROnAgWBcuXPpVKCiooaNH+XgLwFsRRfchiAHOYpHGjrU9fxjgR2MAr0cU3YMgBjgutwB8E1F0PYIY4LjcAvBdRNG1CGIA491pAN9HFF2HIAYwDpcC/oEougZBDGAcLgX8B1GsPoIYoDhcCvgfolg9BDFAcbgU8E9EseoIYoDicCngv4hi1RDEAMThUsD/EcXKI4gBiMOlQGAgipVDEAMQh0uBwEEUnUcQAwyHS4HAQxSdQxADDIdLgcBEFCtGEAMMh0uBwEUUy0cQAwiHSwEQxbIRxADC4VIAElEsC0EMIBwuBVCCKNojiAGCw6UASiOKtghigNi3j8OlAOwRxcsIYgCwWKQ//cl275DDpQBKEMVLCGIA2LcvWD/8UNNmGYdLAVyJKBJEv2exSGPH2u4dcrgUgCOBHkWC6OdKX2rRvPlFrVuXy+FSAA4FchQJop8rfanFq6/+ovBwc8YCwDcEahQJoh/jUgsAVRWIUSSIfoxLLQBUR6BFkSD6KS61AOAKgRRFguinuNQCgKsEShQJoh/iUgsArhYIUSSIfohLLQC4g79HkSD6IS61AOAu/hxFguhnLBZp3DgutQDgPv4aRYLoZw4dCtbevZcPlyYkcO4QgOv5YxQJop+Jjy9Shw6Xjpm2aXNRH33EuUMA7uFvUeSl0s+EhEirV+fq0KFgxccXEUMAblUSxejoaAUFBZk9nGphD9EPhYRIrVoRQwCe4S97igQRAFBt/hBFgggAcAlfjyJBBAC4jC9HkSACAFzKV6NIEAEALueLUSSIAAC38LUoEkQAgNv4UhQJIgDArXwligQRAOB2vhBFgggA8AhvjyJBBAB4jDdHkSACADzKW6NIEAEAHueNUSSIAABTeFsUCSIAwDTeFEWCCAAwlbdEkSACAEznDVEkiAAAr2B2FAkiAMBrmBlFgggA8CpmRZEgAgC8jhlRJIgAAK/k6SgSRACA1/JkFE0P4vz589WiRQuFh4crKSlJmzdvLnf9TZs2KSkpSeHh4WrZsqX+9re/eWikAAAzeCqKpgZx+fLlGj9+vKZMmaLMzEz16NFDffv2VVZWlsP1Dx48qH79+qlHjx7KzMzU448/rnHjxmnFihUeHjkAwJM8EcUgw8SrILt27apOnTppwYIF1mWJiYm6/fbblZaWZrf+Y489plWrVmnPnj3WZWPGjNGOHTuUkZHh1M88c+aMoqKitHfvXtWtW7f6TwIA4DGhoaEKCQlRvXr1lJeXp8jISJc9tml7iIWFhdq2bZtSUlJslqekpGjLli0O75ORkWG3/i233KKtW7fq4sWLbhsrAMA7FBYW6pdffnHLY4e45VGdkJOTo6KiIsXExNgsj4mJ0fHjxx3e5/jx4w7Xt1gsysnJUWxsrN19CgoKVFBQYL2dl5cnSTp79mx1nwIAwAQlr9+uPsBpWhBLBAUF2dw2DMNuWUXrO1peIi0tTTNmzLBbnpSUVNmhAgC8SG5urqKiolz2eKYFsUGDBgoODrbbGzx58qTdXmCJRo0aOVw/JCRE9evXd3ifyZMnKzU11Xr79OnTio+PV1ZWlks3pL85c+aMmjZtqsOHD7v0GL2/YTs5h+3kHLaTc/Ly8tSsWTNFR0e79HFNC2JoaKiSkpKUnp6uO+64w7o8PT1dAwcOdHifbt26afXq1TbL1q9fr86dO6tmzZoO7xMWFqawsDC75VFRUfzCOSEyMpLt5AS2k3PYTs5hOzmnRg3XToMx9bKL1NRUvfHGG1q0aJH27NmjCRMmKCsrS2PGjJF0ae9u2LBh1vXHjBmjQ4cOKTU1VXv27NGiRYu0cOFCPfLII2Y9BQCAnzD1HOKQIUOUm5urmTNnKjs7W+3atdPatWsVHx8vScrOzra5JrFFixZau3atJkyYoHnz5qlx48aaM2eOBg0aZNZTAAD4CdMn1YwdO1Zjx451+L0lS5bYLevZs6e+/fbbKv+8sLAwTZs2zeFhVFzGdnIO28k5bCfnsJ2c467tZOqF+QAAeAvT38sUAABvQBABABBBBABAEkEEAECSnwaRz1h0TmW208qVK3XzzTfr6quvVmRkpLp166aPP/7Yg6M1T2V/n0p88cUXCgkJUceOHd07QC9R2e1UUFCgKVOmKD4+XmFhYWrVqpUWLVrkodGap7LbaenSperQoYMiIiIUGxurkSNHKjc310OjNcdnn32mAQMGqHHjxgoKCtIHH3xQ4X1c8jpu+Jl//vOfRs2aNY3XX3/d2L17t/Hwww8btWvXNg4dOuRw/QMHDhgRERHGww8/bOzevdt4/fXXjZo1axrvvfeeh0fuWZXdTg8//LAxa9Ys4+uvvzb27dtnTJ482ahZs6bx7bffenjknlXZ7VTi9OnTRsuWLY2UlBSjQ4cOnhmsiaqynW677Taja9euRnp6unHw4EHjq6++Mr744gsPjtrzKrudNm/ebNSoUcN4+eWXjQMHDhibN2822rZta9x+++0eHrlnrV271pgyZYqxYsUKQ5Lx/vvvl7u+q17H/S6IXbp0McaMGWOzrE2bNsakSZMcrv/nP//ZaNOmjc2y+++/37jhhhvcNkZvUNnt5Mi1115rzJgxw9VD8ypV3U5DhgwxnnjiCWPatGkBEcTKbqePPvrIiIqKMnJzcz0xPK9R2e303HPPGS1btrRZNmfOHCMuLs5tY/Q2zgTRVa/jfnXIlM9YdE5VtlNpxcXFys/Pd/mb63qTqm6nxYsXa//+/Zo2bZq7h+gVqrKdVq1apc6dO2v27Nlq0qSJWrdurUceeUTnz5/3xJBNUZXtlJycrCNHjmjt2rUyDEMnTpzQe++9p/79+3tiyD7DVa/jpr9TjSt56jMWfV1VtlNpzz//vM6dO6fBgwe7Y4heoSrb6YcfftCkSZO0efNmhYT41T+vMlVlOx04cECff/65wsPD9f777ysnJ0djx47VqVOn/PY8YlW2U3JyspYuXaohQ4bowoULslgsuu222zR37lxPDNlnuOp13K/2EEu4+zMW/UVlt1OJZcuWafr06Vq+fLkaNmzoruF5DWe3U1FRkYYOHaoZM2aodevWnhqe16jM71NxcbGCgoK0dOlSdenSRf369dMLL7ygJUuW+PVeolS57bR7926NGzdOU6dO1bZt27Ru3TodPHjQ+gEIuMwVr+N+9Sespz5j0ddVZTuVWL58uUaNGqV3331Xffr0cecwTVfZ7ZSfn6+tW7cqMzNTDz74oKRLL/yGYSgkJETr169Xr169PDJ2T6rK71NsbKyaNGli85mkiYmJMgxDR44c0TXXXOPWMZuhKtspLS1N3bt316OPPipJuu6661S7dm316NFDTz/9tF8ewaoKV72O+9Ue4pWfsXil9PR0JScnO7xPt27d7Nav6DMWfV1VtpN0ac9wxIgRevvttwPiHEZlt1NkZKR27typ7du3W7/GjBmjhIQEbd++XV27dvXU0D2qKr9P3bt317Fjx3T27Fnrsn379qlGjRqKi4tz63jNUpXt9Ouvv9p95l9wcLCky3tAcOHreKWm4PiAkmnNCxcuNHbv3m2MHz/eqF27tvHTTz8ZhmEYkyZNMu69917r+iXTdSdMmGDs3r3bWLhwYUBdduHsdnr77beNkJAQY968eUZ2drb16/Tp02Y9BY+o7HYqLVBmmVZ2O+Xn5xtxcXHGXXfdZezatcvYtGmTcc011xijR4826yl4RGW30+LFi42QkBBj/vz5xv79+43PP//c6Ny5s9GlSxeznoJH5OfnG5mZmUZmZqYhyXjhhReMzMxM6+Up7nod97sgGoZhzJs3z4iPjzdCQ0ONTp06GZs2bbJ+b/jw4UbPnj1t1t+4caNx/fXXG6GhoUbz5s2NBQsWeHjE5qjMdurZs6chye5r+PDhnh+4h1X29+lKgRJEw6j8dtqzZ4/Rp08fo1atWkZcXJyRmppq/Prrrx4etedVdjvNmTPHuPbaa41atWoZsbGxxh//+EfjyJEjHh61Z3366aflvt6463Wcj38CAEB+dg4RAICqIogAAIggAgAgiSACACCJIAIAIIkgAgAgiSACACCJIAIAIIkgAn6hqKhIycnJGjRokM3yvLw8NW3aVE888YRJIwN8B+9UA/iJH374QR07dtRrr72mP/7xj5KkYcOGaceOHfrmm28UGhpq8ggB70YQAT8yZ84cTZ8+Xd9//72++eYb/f73v9fXX3+tjh07mj00wOsRRMCPGIahXr16KTg4WDt37tRDDz3E4VLASQQR8DP/+c9/lJiYqPbt2+vbb79VSIhffQ444DZMqgH8zKJFixQREaGDBw/qyJEjZg8H8BnsIQJ+JCMjQzfeeKM++ugjzZ49W0VFRfrkk08UFBRk9tAAr8ceIuAnzp8/r+HDh+v+++9Xnz599MYbb+ibb77Rq6++avbQAJ9AEAE/MWnSJBUXF2vWrFmSpGbNmun555/Xo48+qp9++sncwQE+gEOmgB/YtGmTevfurY0bN+o3v/mNzfduueUWWSwWDp0CFSCIAACIQ6YAAEgiiAAASCKIAABIIogAAEgiiAAASCKIAABIIogAAEgiiAAASCKIAABIIogAAEgiiAAASCKIAABIkv4f3LNf+17FEQMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the manifold with geodesic with initial and end point specified\n", + "from geomstats.information_geometry.categorical import CategoricalDistributions, CategoricalMetric\n", + "dist2 = CategoricalDistributions(dim = 2)\n", + "points2 = dist2.random_point(n_samples = 2)\n", + "dist3 = CategoricalDistributions(dim = 3)\n", + "points3 = dist2.random_point(n_samples = 2)\n", + "# Special Cases (On the boundary)\n", + "# points = np.array([[0,0,1], [0,1,0]])\n", + "# points = np.array([[0,0,1], [1,0,0]])\n", + "# points = np.array([[0.25,0.75,0], [0.75,0.25,0]])\n", + "M2.plot_geodesic(initial_point = points2[0], end_point = points2[1])\n", + "M3.plot_geodesic(initial_point = points3[0], end_point = points3[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualization of Geodesics with Initial Point and Initial Tangent Vector Specified" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the manifold with geodesic with initial point and initial tangent_vector specified\n", + "dist3 = CategoricalDistributions(dim = 3)\n", + "vector2 = np.array([1,0,0])\n", + "base_point2 = np.array([0.3, 0.3, 0.4])\n", + "tangent_vector2 = dist2.to_tangent(vector = vector2, base_point= base_point2)\n", + "M2.plot_geodesic(initial_point = base_point2, tangent_vector = tangent_vector2)\n", + "\n", + "vector3 = np.array([1,0,0,0])\n", + "base_point3 = np.array([0.3, 0.3, 0.2, 0.2])\n", + "tangent_vector3 = dist3.to_tangent(vector = vector3, base_point= base_point3)\n", + "M3.plot_geodesic(initial_point = base_point3, tangent_vector = tangent_vector3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Plot the Geodesic Grid for a 2D Manifold" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Geodesic Grid for 2D Manifold\n", + "M2.plot_grid()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Elliptical Geodesic Grid\n", + "The geodesics are elliptical because the Fisher metric embeds an n-simplex into an n-hypersphere. \n", + "Intuitively, the geodesics are elliptical because they are the projection of the geodesics on the n-sphere back to the n-simplex.\n", + "\n", + "
\\\"default\\\"/
\n", + "\n", + "Image Credit: Åström, F., Petra, S., Schmitzer, B. et al. Image Labeling by Assignment. J Math Imaging Vis 58, 211–238 (2017). https://doi.org/10.1007/s10851-016-0702-4\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Visualization of Log\n", + "Given an initial point and an end point, this function plots the tangent vector which when applied to the initial point via the exponential map, we get the endpoint." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualization of Log\n", + "points2 = dist2.random_point(n_samples=2)\n", + "M2.plot_log(points2[0],points2[1])\n", + "\n", + "points3 = dist3.random_point(n_samples=3)\n", + "M3.plot_log(points3[0],points3[1])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Applications\n", + "#### Questionairre Analysis\n", + "Questionaiires often contains categorical data where the user has to select among a few options. Ex. Ethnicity, Nationality, ...\n", + "\n", + "\n", + "Har-Shemesh, O., Quax, R., Lansing, J.S. et al. Questionnaire data analysis using information geometry. Sci Rep 10, 8633 (2020). https://doi.org/10.1038/s41598-020-63760-8" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Color Naming\n", + "Grass usually looks 'green', and the sky usually looks 'blue' to most of us. But given a color somewhere in the middle, when do we tend to characterize it with 'turquoise'?\n", + "\n", + "This is a categorical distribution with 3 categories.\n", + "\n", + "
\\\"default\\\"/
\n", + "\n", + "Griffin LD, Mylonas D (2019) Categorical colour geometry. PLoS ONE 14(5): e0216296.https://doi.org/10.1371/journal.pone.0216296\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "#### Dome Design\n", + "The goal is to design a stable dome with some supporting bars, but we only have bars with certain cross-sectional areas to choose from. \n", + "\n", + "
\\\"default\\\"/
\n", + "\n", + "Gao, Huanhuan et al. “Categorical Structural Optimization Using Discrete Manifold Learning Approach and Custom-Built Evolutionary Operators.” Structural and multidisciplinary optimization 58.1 (2018): 215–228. Web." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "### Final Thoughts\n", + "- This manifold helps us reduce the dimension of a categorical distributions by 1.\n", + "\n", + "- With more constraints or prior information on the distributions, the dimension may be further reduced.\n", + "\n", + "- Applies when the data is constraint to be elements from a finite set." + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "interpreter": { + "hash": "40d444e15d4b5bb908f4b95c26d9b158a336fb6b786751c7d3022d89de8ad3f2" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/images/coins.png b/notebooks/images/coins.png new file mode 100644 index 0000000000000000000000000000000000000000..4f14b3dd79d015c65dec52694005c5f1db7184fb GIT binary patch literal 29015 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ⅆZc~4X$cz6+W#tR!caKJDuTwJ@K?k%0Y?)^^ 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 z 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 S6RLPa5leGhv%@Cy*8U&BB}sh% literal 0 HcmV?d00001 diff --git a/notebooks/images/dice.jpeg b/notebooks/images/dice.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..352380946dd26b9e7ef3ed6daadd4955d4dff44e GIT binary patch literal 41785 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 q^N<_0ueLtmiC1r(p>N%}X87vi-5 literal 0 HcmV?d00001 diff --git a/notebooks/images/dome.jpeg b/notebooks/images/dome.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..39fb4c667e06a4cf39e805857ec11be54ab8471b GIT binary patch literal 94443 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 literal 0 HcmV?d00001 diff --git a/notebooks/images/simplex.png b/notebooks/images/simplex.png new file mode 100644 index 0000000000000000000000000000000000000000..d4cc1d3b20c2356ab079be940a3fb4f35e4d0243 GIT binary patch literal 34846 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%0AU$TMBenGt6dr< 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 XaE)(puz~M>z9u7~_^jlq!Mpzh)m5sZ literal 0 HcmV?d00001