示例#1
0
    def test_1000by6_matrix_auto_tune(self):
        matrix = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]] * 400 +
                          [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]] * 300 +
                          [[0.0, 0.0, 2.0, 0.0, 0.0, 0.0]] * 200 +
                          [[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]] * 100)
        noisy = np.random.rand(1000, 6) * 2 - 1
        matrix = matrix + noisy * 0.1

        refinement_sequence = [RefinementName.RowWiseThreshold]
        refinement_options = refinement.RefinementOptions(
            thresholding_type=ThresholdType.Percentile,
            refinement_sequence=refinement_sequence)
        auto_tune = autotune.AutoTune(p_percentile_min=0.9,
                                      p_percentile_max=0.95,
                                      init_search_step=0.03,
                                      search_level=1)
        clusterer = spectral_clusterer.SpectralClusterer(
            max_clusters=4,
            refinement_options=refinement_options,
            autotune=auto_tune,
            laplacian_type=LaplacianType.GraphCut,
            row_wise_renorm=True)
        labels = clusterer.predict(matrix)
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0] * 400 + [1] * 300 + [2] * 200 + [3] * 100)
        self.assertTrue(np.array_equal(expected, labels))
示例#2
0
    def test_6by2_matrix_auto_tune(self):
        matrix = np.array([
            [1.0, 0.0],
            [1.1, 0.1],
            [0.0, 1.0],
            [0.1, 1.0],
            [0.9, -0.1],
            [0.0, 1.2],
        ])

        refinement_sequence = [RefinementName.RowWiseThreshold]
        refinement_options = refinement.RefinementOptions(
            thresholding_type=ThresholdType.Percentile,
            refinement_sequence=refinement_sequence)
        auto_tune = autotune.AutoTune(p_percentile_min=0.60,
                                      p_percentile_max=0.95,
                                      init_search_step=0.05,
                                      search_level=1)
        clusterer = spectral_clusterer.SpectralClusterer(
            max_clusters=2,
            refinement_options=refinement_options,
            autotune=auto_tune,
            laplacian_type=LaplacianType.GraphCut,
            row_wise_renorm=True)
        labels = clusterer.predict(matrix)
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0, 0, 1, 1, 0, 1])
        self.assertTrue(np.array_equal(expected, labels))
示例#3
0
 def test_1000by6_matrix(self):
     matrix = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]] * 400 +
                       [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]] * 300 +
                       [[0.0, 0.0, 2.0, 0.0, 0.0, 0.0]] * 200 +
                       [[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]] * 100)
     noisy = np.random.rand(1000, 6) * 2 - 1
     matrix = matrix + noisy * 0.1
     labels = configs.icassp2018_clusterer.predict(matrix)
     labels = utils.enforce_ordered_labels(labels)
     expected = np.array([0] * 400 + [1] * 300 + [2] * 200 + [3] * 100)
     self.assertTrue(np.array_equal(expected, labels))
示例#4
0
    def test_1000by6_matrix_euclidean_dist(self):
        matrix = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]] * 400 +
                          [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]] * 300 +
                          [[0.0, 0.0, 2.0, 0.0, 0.0, 0.0]] * 200 +
                          [[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]] * 100)
        noisy = np.random.rand(1000, 6) * 2 - 1
        matrix = matrix + noisy * 0.1

        labels = custom_distance_kmeans.run_kmeans(matrix,
                                                   n_clusters=4,
                                                   max_iter=300,
                                                   custom_dist="euclidean")
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0] * 400 + [1] * 300 + [2] * 200 + [3] * 100)
        self.assertTrue(np.array_equal(expected, labels))
示例#5
0
 def test_1000by6_matrix(self):
     matrix = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]] * 400 +
                       [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]] * 300 +
                       [[0.0, 0.0, 2.0, 0.0, 0.0, 0.0]] * 200 +
                       [[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]] * 100)
     noisy = np.random.rand(1000, 6) * 2 - 1
     matrix = matrix + noisy * 0.1
     refinement_options = refinement.RefinementOptions(
         gaussian_blur_sigma=0,
         p_percentile=0.2,
         refinement_sequence=ICASSP2018_REFINEMENT_SEQUENCE)
     clusterer = spectral_clusterer.SpectralClusterer(
         refinement_options=refinement_options, stop_eigenvalue=0.01)
     labels = clusterer.predict(matrix)
     labels = utils.enforce_ordered_labels(labels)
     expected = np.array([0] * 400 + [1] * 300 + [2] * 200 + [3] * 100)
     self.assertTrue(np.array_equal(expected, labels))
示例#6
0
 def test_6by2_matrix(self):
     matrix = np.array([
         [1.0, 0.0],
         [1.1, 0.1],
         [0.0, 1.0],
         [0.1, 1.0],
         [0.9, -0.1],
         [0.0, 1.2],
     ])
     speaker_turn_scores = [0, 0, 1.5, 0, 1.5, 1.5]
     constraint_matrix = constraint.ConstraintMatrix(
         speaker_turn_scores, threshold=1).compute_diagonals()
     labels = configs.turntodiarize_clusterer.predict(
         matrix, constraint_matrix)
     labels = utils.enforce_ordered_labels(labels)
     expected = np.array([0, 0, 1, 1, 0, 1])
     self.assertTrue(np.array_equal(expected, labels))
示例#7
0
    def test_6by2_matrix_euclidean_dist(self):
        matrix = np.array([
            [1.0, 0.0],
            [1.1, 0.1],
            [0.0, 1.0],
            [0.1, 1.0],
            [0.9, -0.1],
            [0.0, 1.2],
        ])

        labels = custom_distance_kmeans.run_kmeans(matrix,
                                                   n_clusters=2,
                                                   max_iter=300,
                                                   custom_dist="euclidean")
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0, 0, 1, 1, 0, 1])
        self.assertTrue(np.array_equal(expected, labels))
示例#8
0
 def test_6by2_matrix(self):
     matrix = np.array([
         [1.0, 0.0],
         [1.1, 0.1],
         [0.0, 1.0],
         [0.1, 1.0],
         [0.9, -0.1],
         [0.0, 1.2],
     ])
     refinement_options = refinement.RefinementOptions(
         gaussian_blur_sigma=0,
         p_percentile=0.95,
         refinement_sequence=ICASSP2018_REFINEMENT_SEQUENCE)
     clusterer = spectral_clusterer.SpectralClusterer(
         refinement_options=refinement_options)
     labels = clusterer.predict(matrix)
     labels = utils.enforce_ordered_labels(labels)
     expected = np.array([0, 0, 1, 1, 0, 1])
     self.assertTrue(np.array_equal(expected, labels))
示例#9
0
    def test_6by2_matrix_affinity_integration(self):
        matrix = np.array([
            [1.0, 0.0],
            [1.1, 0.1],
            [0.0, 1.0],
            [0.1, 1.0],
            [0.9, -0.1],
            [0.0, 1.2],
        ])

        constraint_matrix = np.array([
            [1, 0, 0, 0, 0, 0],
            [0, 1, 0, 0, 0, 0],
            [0, 0, 1, 1, 1, 1],
            [0, 0, 1, 1, 1, 1],
            [0, 0, 1, 1, 1, 1],
            [0, 0, 1, 1, 1, 1],
        ])

        refinement_sequence = [
            RefinementName.RowWiseThreshold, RefinementName.Symmetrize
        ]
        refinement_options = refinement.RefinementOptions(
            p_percentile=0.95,
            thresholding_type=ThresholdType.Percentile,
            thresholding_with_binarization=True,
            thresholding_preserve_diagonal=True,
            symmetrize_type=SymmetrizeType.Average,
            refinement_sequence=refinement_sequence)
        constraint_options = constraint.ConstraintOptions(
            constraint_name=ConstraintName.AffinityIntegration,
            apply_before_refinement=False,
            integration_type=IntegrationType.Max)
        clusterer = spectral_clusterer.SpectralClusterer(
            max_clusters=2,
            refinement_options=refinement_options,
            constraint_options=constraint_options,
            laplacian_type=LaplacianType.GraphCut,
            row_wise_renorm=True)
        labels = clusterer.predict(matrix, constraint_matrix)
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0, 0, 1, 1, 1, 1])
        self.assertTrue(np.array_equal(expected, labels))
示例#10
0
    def test_1000by6_matrix_normalized_laplacian(self):
        matrix = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0]] * 400 +
                          [[0.0, 1.0, 0.0, 0.0, 0.0, 0.0]] * 300 +
                          [[0.0, 0.0, 2.0, 0.0, 0.0, 0.0]] * 200 +
                          [[0.0, 0.0, 0.0, 1.0, 0.0, 0.0]] * 100)
        noisy = np.random.rand(1000, 6) * 2 - 1
        matrix = matrix + noisy * 0.1

        refinement_sequence = []
        refinement_options = refinement.RefinementOptions(
            p_percentile=0.95, refinement_sequence=refinement_sequence)
        clusterer = spectral_clusterer.SpectralClusterer(
            max_clusters=4,
            refinement_options=refinement_options,
            laplacian_type=LaplacianType.GraphCut,
            row_wise_renorm=True)
        labels = clusterer.predict(matrix)
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0] * 400 + [1] * 300 + [2] * 200 + [3] * 100)
        self.assertTrue(np.array_equal(expected, labels))
示例#11
0
    def test_6by2_matrix_normalized_laplacian(self):
        matrix = np.array([
            [1.0, 0.0],
            [1.1, 0.1],
            [0.0, 1.0],
            [0.1, 1.0],
            [0.9, -0.1],
            [0.0, 1.2],
        ])

        refinement_sequence = []
        refinement_options = refinement.RefinementOptions(
            p_percentile=0.95, refinement_sequence=refinement_sequence)
        clusterer = spectral_clusterer.SpectralClusterer(
            max_clusters=2,
            refinement_options=refinement_options,
            laplacian_type=LaplacianType.GraphCut,
            row_wise_renorm=True)
        labels = clusterer.predict(matrix)
        labels = utils.enforce_ordered_labels(labels)
        expected = np.array([0, 0, 1, 1, 0, 1])
        self.assertTrue(np.array_equal(expected, labels))
示例#12
0
 def test_small_array(self):
   labels = np.array([2, 2, 1, 0, 3, 3, 1])
   expected = np.array([0, 0, 1, 2, 3, 3, 1])
   result = utils.enforce_ordered_labels(labels)
   self.assertTrue(np.array_equal(expected, result))