def _reduce_dim()

in graspologic/embed/mase.py [0:0]

• 57 lines of code
• 13 McCabe index (conditional complexity)

    def _reduce_dim(self, graphs):  # type: ignore
        if self.n_components is None:
            # first embed into log2(n_vertices) for each graph
            n_components = int(np.ceil(np.log2(np.min(self.n_vertices_))))
        else:
            n_components = self.n_components

        # embed individual graphs
        embeddings = [
            select_svd(
                graph,
                n_components=n_components,
                algorithm=self.algorithm,
                n_iter=self.n_iter,
                svd_seed=self.svd_seed,
            )
            for graph in graphs
        ]
        Us, Ds, Vs = zip(*embeddings)

        # Choose the best embedding dimension for each graphs
        if self.n_components is None:
            embedding_dimensions = []
            for D in Ds:
                elbows, _ = select_dimension(D, n_elbows=self.n_elbows)
                embedding_dimensions.append(elbows[-1])

            # Choose the max of all of best embedding dimension of all graphs
            best_dimension = int(np.ceil(np.max(embedding_dimensions)))
        else:
            best_dimension = self.n_components

        if not self.scaled:
            Us = np.hstack([U[:, :best_dimension] for U in Us])
            Vs = np.hstack([V.T[:, :best_dimension] for V in Vs])
        else:
            # Equivalent to ASE
            Us = np.hstack(
                [
                    U[:, :best_dimension] @ np.diag(np.sqrt(D[:best_dimension]))
                    for U, D in zip(Us, Ds)
                ]
            )
            Vs = np.hstack(
                [
                    V.T[:, :best_dimension] @ np.diag(np.sqrt(D[:best_dimension]))
                    for V, D in zip(Vs, Ds)
                ]
            )

        # Second SVD for vertices
        # The notation is slightly different than the paper
        Uhat, sing_vals_left, _ = select_svd(
            Us,
            n_components=self.n_components,
            n_elbows=self.n_elbows,
            algorithm=self.algorithm,
            n_iter=self.n_iter,
            svd_seed=self.svd_seed,
        )

        Vhat, sing_vals_right, _ = select_svd(
            Vs,
            n_components=self.n_components,
            n_elbows=self.n_elbows,
            algorithm=self.algorithm,
            n_iter=self.n_iter,
            svd_seed=self.svd_seed,
        )
        return Uhat, Vhat, sing_vals_left, sing_vals_right