Abstraction

What Abstraction Means in ML Engineering

When you call model.fit(X, y) in scikit-learn, you abstract away whether the solver uses coordinate descent or LBFGS. When you call DataLoader(dataset) in PyTorch, you abstract away whether samples come from JPEGs, Parquet, or a database. Good abstractions reduce cognitive load and enable testing with mocks.

Abstract Base Classes in Python

from abc import ABC, abstractmethod

class BaseDataset(ABC):
    @abstractmethod
    def __len__(self):
        pass

    @abstractmethod
    def __getitem__(self, index):
        pass


class BaseModel(ABC):
    @abstractmethod
    def fit(self, dataset):
        pass

    @abstractmethod
    def predict(self, features):
        pass

You cannot instantiate BaseDataset() directly—Python raises TypeError until every @abstractmethod is implemented in a subclass. This enforces the contract at object creation time.

Capstone: A Mini ML Framework

Let’s build a composable training system. Each piece is abstract; concrete implementations plug in.

1. Concrete Dataset

class ListDataset(BaseDataset):
    def __init__(self, features, labels):
        self._features = features
        self._labels = labels

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

    def __getitem__(self, index):
        return self._features[index], self._labels[index]

2. Concrete Model Wrapper

from sklearn.linear_model import LogisticRegression
import numpy as np

class SklearnClassifierWrapper(BaseModel):
    def __init__(self):
        self._clf = LogisticRegression(max_iter=1000)

    def fit(self, dataset):
        X = np.array([dataset[i][0] for i in range(len(dataset))])
        y = np.array([dataset[i][1] for i in range(len(dataset))])
        self._clf.fit(X, y)

    def predict(self, features):
        return self._clf.predict([features])[0]

3. Abstract Trainer and Evaluator

class Trainer(ABC):
    @abstractmethod
    def run(self, model: BaseModel, train_data: BaseDataset):
        pass


class Evaluator(ABC):
    @abstractmethod
    def score(self, model: BaseModel, test_data: BaseDataset) -> float:
        pass


class SimpleTrainer(Trainer):
    def run(self, model, train_data):
        model.fit(train_data)
        return model


class AccuracyEvaluator(Evaluator):
    def score(self, model, test_data):
        correct = 0
        for i in range(len(test_data)):
            x, y = test_data[i]
            if model.predict(x) == y:
                correct += 1
        return correct / len(test_data)

4. Orchestration — Abstraction in Action

def experiment(train_data, test_data, model, trainer, evaluator):
    """Orchestrator depends ONLY on abstractions — not concrete classes."""
    trained = trainer.run(model, train_data)
    return evaluator.score(trained, test_data)

train = ListDataset([[0, 0], [1, 1], [1, 0]], [0, 1, 1])
test = ListDataset([[0, 1], [1, 1]], [1, 1])

accuracy = experiment(
    train, test,
    SklearnClassifierWrapper(),
    SimpleTrainer(),
    AccuracyEvaluator(),
)
print(f"Accuracy: {accuracy:.2f}")

The Four Pillars in One Pipeline

Abstraction in Real Frameworks

Testing with Abstractions

Abstract interfaces make unit tests easy. Swap a heavy model with a mock:

class MockModel(BaseModel):
    def fit(self, dataset):
        return self

    def predict(self, features):
        return 1   # always predict class 1

# Test evaluator logic without training a real model
mock = MockModel()
assert AccuracyEvaluator().score(mock, test) >= 0.0

Design Guidelines for ML Code

• Define contracts early — What must every dataset provide? Every model? Every metric?
• Keep orchestration thin — Training loops coordinate; they should not embed preprocessing details.
• One class, one job — Dataset loads data; Model predicts; Trainer loops; Evaluator scores.
• Prefer interfaces over globals — Pass objects into functions; avoid module-level mutable state.
• Subclass framework bases — Don’t reinvent nn.Module or Dataset; extend them.

Common Misconceptions

Quick Knowledge Check

Further Reading & References

Official Documentation

• Python abc module — Abstract Base Classes
• PyTorch Data Utilities — Dataset and DataLoader abstractions
• scikit-learn Developer Guide — Estimator API conventions