Classes

Introduction: From Scripts to Blueprints

Imagine a training script with scattered global variables:

learning_rate = 0.001
batch_size = 64
epochs = 10
model_name = "resnet18"
features = [...]
labels = [...]

It works for a notebook experiment, but scaling to multiple experiments, team collaboration, or unit tests becomes painful. Related data and behavior belong together. A class groups them under one name.

In machine learning, classes model recurring entities: a dataset knows how to load and return samples; a model knows how to forward-pass inputs; a trainer knows how to loop over batches. Frameworks ship hundreds of pre-built classes—understanding how to define your own is essential.

Defining a Class

Minimal syntax:

class ModelConfig:
    """Holds hyperparameters for a training run."""

    def __init__(self, learning_rate, batch_size, epochs):
        self.learning_rate = learning_rate
        self.batch_size = batch_size
        self.epochs = epochs

    def summary(self):
        return (
            f"lr={self.learning_rate}, "
            f"batch={self.batch_size}, epochs={self.epochs}"
        )

ML Example: A Tabular Dataset Class

Before PyTorch’s torch.utils.data.Dataset, understand the pattern in plain Python. A dataset class wraps features and labels and exposes a consistent interface:

class TabularDataset:
    """In-memory dataset for tabular ML (features + labels)."""

    def __init__(self, features, labels):
        if len(features) != len(labels):
            raise ValueError("features and labels must have same length")
        self.features = features
        self.labels = labels

    def __len__(self):
        return len(self.features)

    def __getitem__(self, index):
        return self.features[index], self.labels[index]

    def num_features(self):
        return len(self.features[0]) if self.features else 0

Usage:

features = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]
labels = [0, 1, 0]

dataset = TabularDataset(features, labels)
print(len(dataset))           # 3
x, y = dataset[1]             # ([3.0, 4.0], 1)
print(dataset.num_features()) # 2

This mirrors what every deep learning Dataset must provide: length, indexed access, and metadata. PyTorch’s DataLoader expects exactly these dunder methods (__len__, __getitem__).

Class vs. Instance

train_ds = TabularDataset(train_features, train_labels)
val_ds = TabularDataset(val_features, val_labels)

# Same class, different objects, independent state
assert train_ds is not val_ds
assert len(train_ds) != len(val_ds)  # typically

How Frameworks Use Classes

Every major ML library is built on classes:

• PyTorch — nn.Linear, nn.Conv2d, and custom models subclass nn.Module.
• scikit-learn — LogisticRegression, RandomForestClassifier are estimator classes with fit and predict.
• Hugging Face — AutoModel, tokenizers, and trainers are all class-based APIs.

Class Attributes vs. Instance Attributes

Attributes defined directly on the class (outside __init__) are shared by all instances. Instance attributes (assigned via self. in __init__) are per-object.

class ExperimentLogger:
  task_type = "classification"  # class attribute (shared default)

  def __init__(self, run_name):
      self.run_name = run_name    # instance attribute (per experiment)
      self.metrics = {}           # each logger tracks its own metrics

For ML code, prefer instance attributes for data that varies per object (weights, datasets, hyperparameters). Use class attributes sparingly—for constants like default image size or task type.

Common Misconceptions

Quick Knowledge Check