Data Utilities

The data module provides utilities for data loading and preprocessing.

Dataset and DataLoader

Dataset classes for handling data.

class fit.data.dataset.Dataset(X: ndarray | Tensor, y: ndarray | Tensor | None = None, transform: Callable | None = None, target_transform: Callable | None = None)

Bases: object

Base dataset class for handling data.

Wraps arrays and provides indexing functionality.

__init__(X: ndarray | Tensor, y: ndarray | Tensor | None = None, transform: Callable | None = None, target_transform: Callable | None = None)

Initialize dataset.

Parameters:

• X – Input features

• y – Target labels (optional for unsupervised tasks)

• transform – Optional transform to apply to features

• target_transform – Optional transform to apply to targets

__len__() → int

Return the size of the dataset.

__getitem__(idx: int) → Tensor | Tuple[Tensor, Tensor]

Get item by index.

Parameters:

idx – Index of the item

Returns:

(X, y) tuple if y is provided, else just X

split(test_size: float = 0.2, random_state: int | None = None) → Tuple[Dataset, Dataset]

Split dataset into train and test sets.

Parameters:

• test_size – Fraction of data to use for testing

• random_state – Random seed for reproducibility

Returns:

(train_dataset, test_dataset) tuple

shuffle(random_state: int | None = None)

Shuffle the dataset in place.

Parameters:

random_state – Random seed for reproducibility

get_subset(indices: List[int] | ndarray) → Dataset

Get a subset of the dataset.

Parameters:

indices – Indices to include in subset

Returns:

New dataset with selected indices

class fit.data.dataset.TensorDataset(*tensors: Tensor)

Bases: Dataset

Dataset from tensors.

Specialized dataset for when data is already in tensor format.

__init__(*tensors: Tensor)

Initialize tensor dataset.

Parameters:

*tensors – Variable number of tensors (features, targets, etc.)

__len__() → int

Return the size of the dataset.

__getitem__(idx: int) → Tensor | Tuple[Tensor, ...]

Get item by index.

Parameters:

idx – Index of the item

Returns:

Tensor or tuple of tensors

class fit.data.dataset.ConcatDataset(datasets: List[Dataset])

Bases: Dataset

Dataset for concatenating multiple datasets.

__init__(datasets: List[Dataset])

Initialize concatenated dataset.

Parameters:

datasets – List of datasets to concatenate

__len__() → int

Return total size of concatenated datasets.

__getitem__(idx: int)

Get item by global index.

Parameters:

idx – Global index across all datasets

Returns:

Item from appropriate dataset

class fit.data.dataset.Subset(dataset: Dataset, indices: List[int] | ndarray)

Bases: Dataset

Subset of a dataset at specified indices.

__init__(dataset: Dataset, indices: List[int] | ndarray)

Initialize subset.

Parameters:

• dataset – Original dataset

• indices – Indices to include in subset

__len__() → int

Return size of subset.

__getitem__(idx: int)

Get item by subset index.

Parameters:

idx – Index within subset

Returns:

Item from original dataset

class fit.data.dataset.RandomSampler(dataset: Dataset, replacement: bool = False, num_samples: int | None = None, random_state: int | None = None)

Bases: object

Random sampler for datasets.

__init__(dataset: Dataset, replacement: bool = False, num_samples: int | None = None, random_state: int | None = None)

Initialize random sampler.

Parameters:

• dataset – Dataset to sample from

• replacement – Whether to sample with replacement

• num_samples – Number of samples to draw (default: len(dataset))

• random_state – Random seed

__iter__()

Iterator over random indices.

__len__() → int

Return number of samples.

class fit.data.dataset.SequentialSampler(dataset: Dataset)

Bases: object

Sequential sampler for datasets.

__init__(dataset: Dataset)

Initialize sequential sampler.

Parameters:

dataset – Dataset to sample from

__iter__()

Iterator over sequential indices.

__len__() → int

Return number of samples.

DataLoader for batching and iterating over datasets.

class fit.data.dataloader.DataLoader(dataset: Dataset, batch_size: int = 1, shuffle: bool = False, sampler: Any | None = None, drop_last: bool = False, collate_fn: Callable | None = None, random_state: int | None = None)

Bases: object

DataLoader for batching and iterating over datasets.

Provides batching, shuffling, and parallel data loading functionality.

__init__(dataset: Dataset, batch_size: int = 1, shuffle: bool = False, sampler: Any | None = None, drop_last: bool = False, collate_fn: Callable | None = None, random_state: int | None = None)

Initialize DataLoader.

Parameters:

• dataset – Dataset to load from

• batch_size – Number of samples per batch

• shuffle – Whether to shuffle data each epoch

• sampler – Custom sampler (overrides shuffle)

• drop_last – Whether to drop the last incomplete batch

• collate_fn – Function to collate samples into batches

• random_state – Random seed for reproducibility

__iter__() → Iterator

Return iterator over batches.

__len__() → int

Return number of batches.

class fit.data.dataloader.BatchSampler(sampler, batch_size: int, drop_last: bool = False)

Bases: object

Sampler that groups indices into batches.

__init__(sampler, batch_size: int, drop_last: bool = False)

Initialize batch sampler.

Parameters:

• sampler – Base sampler to use

• batch_size – Size of each batch

• drop_last – Whether to drop the last incomplete batch

__iter__()

Iterator over batches of indices.

__len__() → int

Return number of batches.

class fit.data.dataloader.WeightedRandomSampler(weights: list | ndarray, num_samples: int, replacement: bool = True, random_state: int | None = None)

Bases: object

Weighted random sampler for handling class imbalance.

__init__(weights: list | ndarray, num_samples: int, replacement: bool = True, random_state: int | None = None)

Initialize weighted random sampler.

Parameters:

• weights – Weights for each sample

• num_samples – Number of samples to draw

• replacement – Whether to sample with replacement

• random_state – Random seed

__iter__()

Iterator over weighted random indices.

__len__() → int

Return number of samples.

class fit.data.dataloader.SubsetRandomSampler(indices: list | ndarray, random_state: int | None = None)

Bases: object

Random sampler for a subset of indices.

__init__(indices: list | ndarray, random_state: int | None = None)

Initialize subset random sampler.

Parameters:

• indices – Subset of indices to sample from

• random_state – Random seed

__iter__()

Iterator over shuffled subset indices.

__len__() → int

Return number of indices.

class fit.data.dataloader.DistributedSampler(dataset: Dataset, num_replicas: int = 1, rank: int = 0, shuffle: bool = True, random_state: int | None = None)

Bases: object

Sampler for distributed training (placeholder implementation).

__init__(dataset: Dataset, num_replicas: int = 1, rank: int = 0, shuffle: bool = True, random_state: int | None = None)

Initialize distributed sampler.

Parameters:

• dataset – Dataset to sample from

• num_replicas – Number of processes participating in distributed training

• rank – Rank of current process

• shuffle – Whether to shuffle data

• random_state – Random seed

__iter__()

Iterator over distributed indices.

__len__() → int

Return number of samples for this rank.

set_epoch(epoch: int)

Set epoch for shuffling.

fit.data.dataloader.collate_tensors(batch)

Collate function for tensor data.

Parameters:

batch – List of tensor samples

Returns:

Batched tensor

fit.data.dataloader.collate_sequences(batch, pad_value=0)

Collate function for variable-length sequences.

Parameters:

• batch – List of sequence samples

• pad_value – Value to use for padding

Returns:

Padded batch tensor

fit.data.dataloader.pin_memory(tensor)

Pin tensor memory (placeholder for GPU acceleration).

Parameters:

tensor – Tensor to pin

Returns:

Tensor (unchanged in CPU-only implementation)

class fit.data.dataloader.DataLoaderIter(loader: DataLoader)

Bases: object

Iterator for DataLoader with additional functionality.

__init__(loader: DataLoader)

Initialize DataLoader iterator.

Parameters:

loader – DataLoader to iterate over

__iter__()

Return self as iterator.

__next__()

Get next batch.

__len__()

Return number of batches.

property batch_index

Current batch index.

Built-in Datasets

Data Transformations

Feature Selection

Feature selection utilities for machine learning.

This module provides tools for selecting the most relevant features from datasets, including univariate and model-based selection methods.

class fit.data.feature_selection.SelectKBest(score_func: Callable | None = None, k: int = 10)

Bases: object

Select features according to the k highest scores.

Examples

>>> from fit.data.feature_selection import SelectKBest, f_classif
>>> selector = SelectKBest(score_func=f_classif, k=5)
>>> X_new = selector.fit_transform(X, y)

__init__(score_func: Callable | None = None, k: int = 10)

Initialize SelectKBest.

Parameters:

• score_func – Function taking two arrays X and y, and returning scores and p-values

• k – Number of top features to select

fit(X: ndarray, y: ndarray) → SelectKBest

Run score function on (X, y) and get the appropriate features.

Parameters:

• X – Training data

• y – Target values

Returns:

Self for method chaining

transform(X: ndarray) → ndarray

Reduce X to the selected features.

Parameters:

X – Input data

Returns:

Data with selected features only

fit_transform(X: ndarray, y: ndarray) → ndarray

Fit to data, then transform it.

Parameters:

• X – Training data

• y – Target values

Returns:

Data with selected features

get_support(indices: bool = False) → ndarray | List[int]

Get a mask, or integer index, of the selected features.

Parameters:

indices – If True, return feature indices instead of mask

Returns:

Boolean mask or feature indices

class fit.data.feature_selection.SelectPercentile(score_func: Callable | None = None, percentile: int = 10)

Bases: object

Select features according to a percentile of the highest scores.

Examples

>>> selector = SelectPercentile(score_func=f_classif, percentile=20)
>>> X_new = selector.fit_transform(X, y)

__init__(score_func: Callable | None = None, percentile: int = 10)

Initialize SelectPercentile.

Parameters:

• score_func – Function taking two arrays X and y, and returning scores

• percentile – Percent of features to keep

fit(X: ndarray, y: ndarray) → SelectPercentile

Run score function on (X, y) and get the appropriate features.

Parameters:

• X – Training data

• y – Target values

Returns:

Self for method chaining

transform(X: ndarray) → ndarray

Reduce X to the selected features.

Parameters:

X – Input data

Returns:

Data with selected features only

fit_transform(X: ndarray, y: ndarray) → ndarray

Fit to data, then transform it.

Parameters:

• X – Training data

• y – Target values

Returns:

Data with selected features

class fit.data.feature_selection.VarianceThreshold(threshold: float = 0.0)

Bases: object

Feature selector that removes all low-variance features.

Examples

>>> selector = VarianceThreshold(threshold=0.1)
>>> X_new = selector.fit_transform(X)

__init__(threshold: float = 0.0)

Initialize VarianceThreshold.

Parameters:

threshold – Features with variance below this threshold will be removed

fit(X: ndarray, y: ndarray | None = None) → VarianceThreshold

Learn which features have variance above the threshold.

Parameters:

• X – Training data

• y – Not used, present for API consistency

Returns:

Self for method chaining

transform(X: ndarray) → ndarray

Reduce X to the selected features.

Parameters:

X – Input data

Returns:

Data with selected features only

fit_transform(X: ndarray, y: ndarray | None = None) → ndarray

Fit to data, then transform it.

Parameters:

• X – Training data

• y – Not used, present for API consistency

Returns:

Data with selected features

class fit.data.feature_selection.RFE(estimator, n_features_to_select: int | None = None, step: int = 1)

Bases: object

Recursive Feature Elimination.

Given an external estimator that assigns weights to features, RFE recursively eliminates features and builds the model with the remaining attributes.

Examples

>>> from fit.nn.modules.linear import Linear
>>> estimator = Linear(10, 1)  # Simple linear model
>>> selector = RFE(estimator, n_features_to_select=5)
>>> X_new = selector.fit_transform(X, y)

__init__(estimator, n_features_to_select: int | None = None, step: int = 1)

Initialize RFE.

Parameters:

• estimator – Supervised learning estimator with a fit method

• n_features_to_select – Number of features to select

• step – Number of features to remove at each iteration

fit(X: ndarray, y: ndarray) → RFE

Fit the RFE model.

Parameters:

• X – Training data

• y – Target values

Returns:

Self for method chaining

transform(X: ndarray) → ndarray

Reduce X to the selected features.

Parameters:

X – Input data

Returns:

Data with selected features only

fit_transform(X: ndarray, y: ndarray) → ndarray

Fit to data, then transform it.

Parameters:

• X – Training data

• y – Target values

Returns:

Data with selected features

fit.data.feature_selection.f_classif(X: ndarray, y: ndarray) → Tuple[ndarray, ndarray]

Compute the ANOVA F-value for the provided sample.

Parameters:

• X – Sample data

• y – Target values

Returns:

Tuple of (F-statistics, p-values)

fit.data.feature_selection.f_regression(X: ndarray, y: ndarray) → Tuple[ndarray, ndarray]

Univariate linear regression tests.

Parameters:

• X – Sample data

• y – Target values

Returns:

Tuple of (F-statistics, p-values)

fit.data.feature_selection.mutual_info_classif(X: ndarray, y: ndarray) → Tuple[ndarray, ndarray]

Estimate mutual information for a discrete target variable.

Parameters:

• X – Sample data

• y – Target values

Returns:

Tuple of (mutual information scores, dummy p-values)

Preprocessing

Data preprocessing utilities for machine learning.

This module provides tools for encoding categorical variables, scaling features, and other preprocessing tasks.

class fit.data.preprocessing.LabelEncoder

Bases: object

Encode target labels with value between 0 and n_classes-1.

Examples

>>> encoder = LabelEncoder()
>>> labels = ['cat', 'dog', 'cat', 'bird']
>>> encoded = encoder.fit_transform(labels)
>>> print(encoded)  # [0, 1, 0, 2]
>>> decoded = encoder.inverse_transform(encoded)
>>> print(decoded)  # ['cat', 'dog', 'cat', 'bird']

__init__()

fit(y: List | ndarray) → LabelEncoder

Fit label encoder.

Parameters:

y – Target values

Returns:

Self for method chaining

transform(y: List | ndarray) → ndarray

Transform labels to normalized encoding.

Parameters:

y – Target values

Returns:

Encoded labels

fit_transform(y: List | ndarray) → ndarray

Fit label encoder and return encoded labels.

Parameters:

y – Target values

Returns:

Encoded labels

inverse_transform(y: ndarray) → ndarray

Transform labels back to original encoding.

Parameters:

y – Encoded target values

Returns:

Original labels

class fit.data.preprocessing.OneHotEncoder(sparse: bool = False, drop: str | None = None)

Bases: object

Encode categorical features as a one-hot numeric array.

Examples

>>> encoder = OneHotEncoder()
>>> data = [['cat'], ['dog'], ['cat'], ['bird']]
>>> encoded = encoder.fit_transform(data)
>>> print(encoded.shape)  # (4, 3)

__init__(sparse: bool = False, drop: str | None = None)

Initialize OneHotEncoder.

Parameters:

• sparse – Return sparse matrix if True (not implemented yet)

• drop – Strategy to use to drop one category per feature (not implemented yet)

fit(X: List | ndarray) → OneHotEncoder

Fit OneHotEncoder to X.

Parameters:

X – Input samples

Returns:

Self for method chaining

transform(X: List | ndarray) → ndarray

Transform X using one-hot encoding.

Parameters:

X – Input samples

Returns:

One-hot encoded array

fit_transform(X: List | ndarray) → ndarray

Fit OneHotEncoder and transform X.

Parameters:

X – Input samples

Returns:

One-hot encoded array

get_feature_names_out(input_features: List[str] | None = None) → List[str]

Get output feature names for transformation.

Parameters:

input_features – Input feature names

Returns:

Output feature names

class fit.data.preprocessing.StandardScaler(with_mean: bool = True, with_std: bool = True)

Bases: object

Standardize features by removing the mean and scaling to unit variance.

Examples

>>> scaler = StandardScaler()
>>> X = [[1, 2], [3, 4], [5, 6]]
>>> X_scaled = scaler.fit_transform(X)

__init__(with_mean: bool = True, with_std: bool = True)

Initialize StandardScaler.

Parameters:

• with_mean – Center the data before scaling

• with_std – Scale the data to unit variance

fit(X: ndarray) → StandardScaler

Compute the mean and std to be used for later scaling.

Parameters:

X – Training data

Returns:

Self for method chaining

transform(X: ndarray) → ndarray

Perform standardization by centering and scaling.

Parameters:

X – Data to transform

Returns:

Transformed data

fit_transform(X: ndarray) → ndarray

Fit to data, then transform it.

Parameters:

X – Training data

Returns:

Transformed data

inverse_transform(X: ndarray) → ndarray

Scale back the data to the original representation.

Parameters:

X – Transformed data

Returns:

Original scale data

class fit.data.preprocessing.MinMaxScaler(feature_range: tuple = (0, 1))

Bases: object

Transform features by scaling each feature to a given range.

Examples

>>> scaler = MinMaxScaler()
>>> X = [[1, 2], [3, 4], [5, 6]]
>>> X_scaled = scaler.fit_transform(X)  # Scale to [0, 1]

__init__(feature_range: tuple = (0, 1))

Initialize MinMaxScaler.

Parameters:

feature_range – Desired range of transformed data

fit(X: ndarray) → MinMaxScaler

Compute the minimum and maximum to be used for later scaling.

Parameters:

X – Training data

Returns:

Self for method chaining

transform(X: ndarray) → ndarray

Scale features according to feature_range.

Parameters:

X – Data to transform

Returns:

Transformed data

fit_transform(X: ndarray) → ndarray

Fit to data, then transform it.

Parameters:

X – Training data

Returns:

Transformed data

inverse_transform(X: ndarray) → ndarray

Undo the scaling of X according to feature_range.

Parameters:

X – Transformed data

Returns:

Original scale data