Skip to content

incremental_dimension_reduction

Bases: object

A base class for incremental dimension reduction methods.

This class provides a framework for implementing incremental dimension reduction techniques, with methods for setting the number of features, fitting, transforming, and reducing data.

Attributes:

Name Type Description
name str

The name of the dimension reduction method.
n_feature (int, optional)

The number of features to retain after reduction.
incremental (bool, optional)

Whether the dimension reduction is performed incrementally.

Methods:

Name Description
get_n_feature

Retrieve the number of features to retain.
set_n_feature

Set the number of features to retain.
__call__

Forward the input data through the dimension reduction process.
forward

Perform dimension reduction on the input data.
fit_transform

Fit the model to the input data and reduce its dimensionality.
fit

Abstract method for fitting the model to the input data.
transform

Abstract method for transforming input data based on the fitted model.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
 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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
class incremental_dimension_reduction(object):
    """
        A base class for incremental dimension reduction methods.

        This class provides a framework for implementing incremental dimension reduction techniques,
        with methods for setting the number of features, fitting, transforming, and reducing data.

        Attributes
        ----------
        name : str
            The name of the dimension reduction method.
        n_feature : int, optional
            The number of features to retain after reduction.
        incremental : bool, optional
            Whether the dimension reduction is performed incrementally.

        Methods
        -------
        get_n_feature()
            Retrieve the number of features to retain.
        set_n_feature(n_feature)
            Set the number of features to retain.
        __call__(X, device='cup', *args, **kwargs)
            Forward the input data through the dimension reduction process.
        forward(X, device='cup', *args, **kwargs)
            Perform dimension reduction on the input data.
        fit_transform(X, device='cup', *args, **kwargs)
            Fit the model to the input data and reduce its dimensionality.
        fit(X, device='cup', *args, **kwargs)
            Abstract method for fitting the model to the input data.
        transform(X, device='cup', *args, **kwargs)
            Abstract method for transforming input data based on the fitted model.
    """
    def __init__(self, name: str = 'incremental_dimension_reduction', n_feature: int = None, incremental: bool = True, *args, **kwargs):
        """
            Initialize the incremental dimension reduction class.

            Parameters
            ----------
            name : str, optional
                The name of the dimension reduction method. Default is 'incremental_dimension_reduction'.
            n_feature : int, optional
                The number of features to retain after reduction. Default is None.
            incremental : bool, optional
                Whether the dimension reduction is performed incrementally. Default is True.
            *args, **kwargs
                Additional arguments for subclass initialization.
        """
        super().__init__(*args, **kwargs)
        self.name = name
        self.incremental = incremental
        self.n_feature = n_feature

    def get_n_feature(self):
        """
            Retrieve the number of features to retain.

            Returns
            -------
            int
                The number of features to retain.
        """
        return self.n_feature

    def set_n_feature(self, n_feature):
        """
            Set the number of features to retain.

            Parameters
            ----------
            n_feature : int
                The number of features to retain.
        """
        self.n_feature = n_feature

    def __call__(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
        """
            Forward the input data through the dimension reduction process.

            Parameters
            ----------
            X : Union[np.ndarray, torch.Tensor]
                The input data to reduce.
            device : str, optional
                The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
            *args, **kwargs
                Additional arguments for the forward process.

            Returns
            -------
            Union[np.ndarray, torch.Tensor]
                The reduced input data.
        """
        return self.forward(X=X, device=device, *args, **kwargs)

    def forward(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
        """
            Perform dimension reduction on the input data.

            Parameters
            ----------
            X : Union[np.ndarray, torch.Tensor]
                The input data to reduce.
            device : str, optional
                The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
            *args, **kwargs
                Additional arguments for the forward process.

            Returns
            -------
            Union[np.ndarray, torch.Tensor]
                The reduced input data.
        """
        if isinstance(X, torch.Tensor):
            input_X = X.detach().cpu().numpy()  # Convert torch.Tensor to numpy
        else:
            input_X = X
        X_reduced = self.fit_transform(X=input_X, device=device, *args, **kwargs)
        return torch.tensor(X_reduced) if isinstance(X, torch.Tensor) and not isinstance(X_reduced, torch.Tensor) else X_reduced

    def fit_transform(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
        """
            Fit the model to the input data and reduce its dimensionality.

            Parameters
            ----------
            X : Union[np.ndarray, torch.Tensor]
                The input data to reduce.
            device : str, optional
                The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
            *args, **kwargs
                Additional arguments for the fit and transform processes.

            Returns
            -------
            Union[np.ndarray, torch.Tensor]
                The reduced input data.
        """
        if isinstance(X, torch.Tensor):
            input_X = X.detach().cpu().numpy()  # Convert torch.Tensor to numpy
        else:
            input_X = X

        self.fit(X=input_X, device=device, *args, **kwargs)
        X_reduced = self.transform(X=input_X, device=device, *args, **kwargs)

        return torch.tensor(X_reduced) if isinstance(X, torch.Tensor) and not isinstance(X_reduced, torch.Tensor) else X_reduced


    @abstractmethod
    def fit(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
        """
            Abstract method for fitting the model to the input data.

            Parameters
            ----------
            X : Union[np.ndarray, torch.Tensor]
                The input data to fit.
            device : str, optional
                The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
            *args, **kwargs
                Additional arguments for the fitting process.

            Raises
            ------
            NotImplementedError
                This method must be implemented in subclasses.
        """
        pass

    @abstractmethod
    def transform(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
        """
            Abstract method for transforming input data based on the fitted model.

            Parameters
            ----------
            X : Union[np.ndarray, torch.Tensor]
                The input data to transform.
            device : str, optional
                The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
            *args, **kwargs
                Additional arguments for the transformation process.

            Raises
            ------
            NotImplementedError
                This method must be implemented in subclasses.
        """
        pass

__call__(X, device='cup', *args, **kwargs)

Forward the input data through the dimension reduction process.

Parameters:

Name Type Description Default
X Union[ndarray, Tensor]

The input data to reduce.

 required
device str

The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.

 'cup'
*args

Additional arguments for the forward process.

 ()
**kwargs

Additional arguments for the forward process.

 ()

Returns:

Type Description
Union[ndarray, Tensor]

The reduced input data.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
def __call__(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
    """
        Forward the input data through the dimension reduction process.

        Parameters
        ----------
        X : Union[np.ndarray, torch.Tensor]
            The input data to reduce.
        device : str, optional
            The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
        *args, **kwargs
            Additional arguments for the forward process.

        Returns
        -------
        Union[np.ndarray, torch.Tensor]
            The reduced input data.
    """
    return self.forward(X=X, device=device, *args, **kwargs)

__init__(name='incremental_dimension_reduction', n_feature=None, incremental=True, *args, **kwargs)

Initialize the incremental dimension reduction class.

Parameters:

Name Type Description Default
name str

The name of the dimension reduction method. Default is 'incremental_dimension_reduction'.

 'incremental_dimension_reduction'
n_feature int

The number of features to retain after reduction. Default is None.

 None
incremental bool

Whether the dimension reduction is performed incrementally. Default is True.

 True
*args

Additional arguments for subclass initialization.

 ()
**kwargs

Additional arguments for subclass initialization.

 ()
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def __init__(self, name: str = 'incremental_dimension_reduction', n_feature: int = None, incremental: bool = True, *args, **kwargs):
    """
        Initialize the incremental dimension reduction class.

        Parameters
        ----------
        name : str, optional
            The name of the dimension reduction method. Default is 'incremental_dimension_reduction'.
        n_feature : int, optional
            The number of features to retain after reduction. Default is None.
        incremental : bool, optional
            Whether the dimension reduction is performed incrementally. Default is True.
        *args, **kwargs
            Additional arguments for subclass initialization.
    """
    super().__init__(*args, **kwargs)
    self.name = name
    self.incremental = incremental
    self.n_feature = n_feature

fit(X, device='cup', *args, **kwargs) abstractmethod

Abstract method for fitting the model to the input data.

Parameters:

Name Type Description Default
X Union[ndarray, Tensor]

The input data to fit.

 required
device str

The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.

 'cup'
*args

Additional arguments for the fitting process.

 ()
**kwargs

Additional arguments for the fitting process.

 ()

Raises:

Type Description
NotImplementedError

This method must be implemented in subclasses.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
@abstractmethod
def fit(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
    """
        Abstract method for fitting the model to the input data.

        Parameters
        ----------
        X : Union[np.ndarray, torch.Tensor]
            The input data to fit.
        device : str, optional
            The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
        *args, **kwargs
            Additional arguments for the fitting process.

        Raises
        ------
        NotImplementedError
            This method must be implemented in subclasses.
    """
    pass

fit_transform(X, device='cup', *args, **kwargs)

Fit the model to the input data and reduce its dimensionality.

Parameters:

Name Type Description Default
X Union[ndarray, Tensor]

The input data to reduce.

 required
device str

The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.

 'cup'
*args

Additional arguments for the fit and transform processes.

 ()
**kwargs

Additional arguments for the fit and transform processes.

 ()

Returns:

Type Description
Union[ndarray, Tensor]

The reduced input data.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
def fit_transform(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
    """
        Fit the model to the input data and reduce its dimensionality.

        Parameters
        ----------
        X : Union[np.ndarray, torch.Tensor]
            The input data to reduce.
        device : str, optional
            The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
        *args, **kwargs
            Additional arguments for the fit and transform processes.

        Returns
        -------
        Union[np.ndarray, torch.Tensor]
            The reduced input data.
    """
    if isinstance(X, torch.Tensor):
        input_X = X.detach().cpu().numpy()  # Convert torch.Tensor to numpy
    else:
        input_X = X

    self.fit(X=input_X, device=device, *args, **kwargs)
    X_reduced = self.transform(X=input_X, device=device, *args, **kwargs)

    return torch.tensor(X_reduced) if isinstance(X, torch.Tensor) and not isinstance(X_reduced, torch.Tensor) else X_reduced

forward(X, device='cup', *args, **kwargs)

Perform dimension reduction on the input data.

Parameters:

Name Type Description Default
X Union[ndarray, Tensor]

The input data to reduce.

 required
device str

The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.

 'cup'
*args

Additional arguments for the forward process.

 ()
**kwargs

Additional arguments for the forward process.

 ()

Returns:

Type Description
Union[ndarray, Tensor]

The reduced input data.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
def forward(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
    """
        Perform dimension reduction on the input data.

        Parameters
        ----------
        X : Union[np.ndarray, torch.Tensor]
            The input data to reduce.
        device : str, optional
            The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
        *args, **kwargs
            Additional arguments for the forward process.

        Returns
        -------
        Union[np.ndarray, torch.Tensor]
            The reduced input data.
    """
    if isinstance(X, torch.Tensor):
        input_X = X.detach().cpu().numpy()  # Convert torch.Tensor to numpy
    else:
        input_X = X
    X_reduced = self.fit_transform(X=input_X, device=device, *args, **kwargs)
    return torch.tensor(X_reduced) if isinstance(X, torch.Tensor) and not isinstance(X_reduced, torch.Tensor) else X_reduced

get_n_feature()

Retrieve the number of features to retain.

Returns:

Type Description
int

The number of features to retain.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
71
72
73
74
75
76
77
78
79
80
def get_n_feature(self):
    """
        Retrieve the number of features to retain.

        Returns
        -------
        int
            The number of features to retain.
    """
    return self.n_feature

set_n_feature(n_feature)

Set the number of features to retain.

Parameters:

Name Type Description Default
n_feature int

The number of features to retain.

 required
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
82
83
84
85
86
87
88
89
90
91
def set_n_feature(self, n_feature):
    """
        Set the number of features to retain.

        Parameters
        ----------
        n_feature : int
            The number of features to retain.
    """
    self.n_feature = n_feature

transform(X, device='cup', *args, **kwargs) abstractmethod

Abstract method for transforming input data based on the fitted model.

Parameters:

Name Type Description Default
X Union[ndarray, Tensor]

The input data to transform.

 required
device str

The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.

 'cup'
*args

Additional arguments for the transformation process.

 ()
**kwargs

Additional arguments for the transformation process.

 ()

Raises:

Type Description
NotImplementedError

This method must be implemented in subclasses.
Source code in tinybig/koala/machine_learning/dimension_reduction/incremental_dimension_reduction.py 
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
@abstractmethod
def transform(self, X: Union[np.ndarray, torch.Tensor], device: str = 'cup', *args, **kwargs):
    """
        Abstract method for transforming input data based on the fitted model.

        Parameters
        ----------
        X : Union[np.ndarray, torch.Tensor]
            The input data to transform.
        device : str, optional
            The device to use for computation ('cpu' or 'cuda'). Default is 'cup'.
        *args, **kwargs
            Additional arguments for the transformation process.

        Raises
        ------
        NotImplementedError
            This method must be implemented in subclasses.
    """
    pass