Skip to content

SGtSNEpi — Sklearn Estimator

Sklearn-compatible estimator for SG-t-SNE-Pi.

SGtSNEpi

Bases: BaseEstimator, TransformerMixin

SG-t-SNE-Pi graph embedding.

Parameters:

Name Type Description Default
d int

Embedding dimensions (default 2).

 2
lambda_ float

Rescaling parameter (default 10).

 10.0
n_neighbors int

Number of nearest neighbors for kNN (default 15).

 15
metric str

Distance metric (default "euclidean").

 'euclidean'
max_iter int

Maximum iterations (default 1000).

 1000
early_exag int

Early exaggeration iterations (default 250).

 250
alpha float

Exaggeration multiplier (default 12).

 12.0
eta float

Learning rate (default 200).

 200.0
h float

Grid side length for FFT. 0 = auto.

 0.0
random_state int or None

Random seed.

 None
unweighted_to_weighted bool

If True (default) and the input graph is unweighted, compute Jaccard-index local weights before embedding.

 True
Source code in src/pysgtsnepi/estimator.py 
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
class SGtSNEpi(BaseEstimator, TransformerMixin):
    """SG-t-SNE-Pi graph embedding.

    Parameters
    ----------
    d : int
        Embedding dimensions (default 2).
    lambda_ : float
        Rescaling parameter (default 10).
    n_neighbors : int
        Number of nearest neighbors for kNN (default 15).
    metric : str
        Distance metric (default "euclidean").
    max_iter : int
        Maximum iterations (default 1000).
    early_exag : int
        Early exaggeration iterations (default 250).
    alpha : float
        Exaggeration multiplier (default 12).
    eta : float
        Learning rate (default 200).
    h : float
        Grid side length for FFT. 0 = auto.
    random_state : int or None
        Random seed.
    unweighted_to_weighted : bool
        If True (default) and the input graph is unweighted, compute
        Jaccard-index local weights before embedding.
    """

    def __init__(
        self,
        d: int = 2,
        lambda_: float = 10.0,
        n_neighbors: int = 15,
        metric: str = "euclidean",
        max_iter: int = 1000,
        early_exag: int = 250,
        alpha: float = 12.0,
        eta: float = 200.0,
        h: float = 0.0,
        random_state: int | None = None,
        unweighted_to_weighted: bool = True,
    ):
        self.d = d
        self.lambda_ = lambda_
        self.n_neighbors = n_neighbors
        self.metric = metric
        self.max_iter = max_iter
        self.early_exag = early_exag
        self.alpha = alpha
        self.eta = eta
        self.h = h
        self.random_state = random_state
        self.unweighted_to_weighted = unweighted_to_weighted

    def fit(self, X, y=None):
        """Compute the embedding.

        Parameters
        ----------
        X : array-like or sparse matrix of shape (n_samples, n_features)
            If dense, builds kNN graph first.
            If sparse, treats as adjacency matrix.

        Returns
        -------
        self
        """
        self.fit_transform(X, y)
        return self

    def fit_transform(self, X, y=None):
        """Compute and return the embedding.

        Parameters
        ----------
        X : array-like or sparse matrix of shape (n_samples, n_features)
            If dense, builds kNN graph first.
            If sparse, treats as adjacency matrix.

        Returns
        -------
        Y : ndarray of shape (n_samples, d)
        """
        if issparse(X):
            A = X
        else:
            X = np.asarray(X, dtype=np.float64)
            A = build_knn_graph(
                X,
                n_neighbors=self.n_neighbors,
                metric=self.metric,
                random_state=self.random_state,
                perplexity=self.lambda_,
            )

        Y = sgtsnepi(
            A,
            d=self.d,
            lambda_=self.lambda_,
            max_iter=self.max_iter,
            early_exag=self.early_exag,
            alpha=self.alpha,
            eta=self.eta,
            h=self.h,
            random_state=self.random_state,
            unweighted_to_weighted=self.unweighted_to_weighted,
        )

        self.embedding_ = Y
        return Y

fit(X, y=None)

Compute the embedding.

Parameters:

Name Type Description Default
X array-like or sparse matrix of shape (n_samples, n_features)

If dense, builds kNN graph first. If sparse, treats as adjacency matrix.

 required

Returns:

Type Description
self
Source code in src/pysgtsnepi/estimator.py 
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
def fit(self, X, y=None):
    """Compute the embedding.

    Parameters
    ----------
    X : array-like or sparse matrix of shape (n_samples, n_features)
        If dense, builds kNN graph first.
        If sparse, treats as adjacency matrix.

    Returns
    -------
    self
    """
    self.fit_transform(X, y)
    return self

fit_transform(X, y=None)

Compute and return the embedding.

Parameters:

Name Type Description Default
X array-like or sparse matrix of shape (n_samples, n_features)

If dense, builds kNN graph first. If sparse, treats as adjacency matrix.

 required

Returns:

Name Type Description
Y ndarray of shape (n_samples, d)
Source code in src/pysgtsnepi/estimator.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def fit_transform(self, X, y=None):
    """Compute and return the embedding.

    Parameters
    ----------
    X : array-like or sparse matrix of shape (n_samples, n_features)
        If dense, builds kNN graph first.
        If sparse, treats as adjacency matrix.

    Returns
    -------
    Y : ndarray of shape (n_samples, d)
    """
    if issparse(X):
        A = X
    else:
        X = np.asarray(X, dtype=np.float64)
        A = build_knn_graph(
            X,
            n_neighbors=self.n_neighbors,
            metric=self.metric,
            random_state=self.random_state,
            perplexity=self.lambda_,
        )

    Y = sgtsnepi(
        A,
        d=self.d,
        lambda_=self.lambda_,
        max_iter=self.max_iter,
        early_exag=self.early_exag,
        alpha=self.alpha,
        eta=self.eta,
        h=self.h,
        random_state=self.random_state,
        unweighted_to_weighted=self.unweighted_to_weighted,
    )

    self.embedding_ = Y
    return Y