ComposerModel

class composer.ComposerModel

The interface needed to make a PyTorch model compatible with composer.Trainer.

To create a Trainer-compatible model, subclass ComposerModel and implement forward() and loss(). For full functionality (logging and validation), implement get_metrics() and eval_forward().

See the Composer Model walk through for more details.

Minimal Example:

import torchvision
import torch.nn.functional as F

from composer.models import ComposerModel

class ResNet18(ComposerModel):

    def __init__(self):
        super().__init__()
        self.model = torchvision.models.resnet18() # define PyTorch model in __init__.

    def forward(self, batch): # batch is the output of the dataloader
        # specify how batches are passed through the model
        inputs, _ = batch
        return self.model(inputs)

    def loss(self, outputs, batch):
        # pass batches and `forward` outputs to the loss
        _, targets = batch
        return F.cross_entropy(outputs, targets)

logger

The training Logger. The trainer sets the Logger on the:attr:.Event.INIT event.

Type

Optional[Logger]

eval_forward(batch, outputs=None)

Run the evaluation forward pass.

By default, it returns the outputs if they are not None. Otherwise, self(batch) is returned.

Override this method for models that require custom validation logic – e.g. self-supervised learning.

Parameters

• batch – The dataloader batch.

• outputs (Any, optional) – If training, the outputs from the forward pass. Otherwise, None.

Returns

Any – The evaluation outputs.

abstract forward(batch)

Compute model output given a batch from the dataloader.

Parameters

batch (Batch) – The output batch from dataloader.

Returns

Tensor | Sequence[Tensor] – The result that is passed to loss() as the parameter outputs.

Warning

This method is different from vanilla PyTorch model.forward(x) or model(x) as it takes a batch of data that has to be unpacked.

Example:

def forward(self, batch): # batch is the output of the dataloader
    inputs, _ = batch
    return self.model(inputs)

The outputs of forward() are passed to loss() by the trainer:

for batch in train_dataloader:
    optimizer.zero_grad()
    outputs = model.forward(batch)
    loss = model.loss(outputs, batch)
    loss.backward()

get_metrics(is_train)

Get the metrics.

This method will be called by the trainer immediately after Event.INIT.

Note

Each item in the returned dictionary will be copy.deepcopy before it is used. This is to ensure that each dataloader (e.g. train, eval) will be accumulating metrics separately.

To share a metric across all dataloaders, wrap it with MetricSpec(metric=metric, share=False).

Parameters

is_train (bool) – Whether the training metrics or evaluation metrics should be returned.

Returns

Dict[str, Metric] – A mapping of the metric name to a Metric.

abstract loss(outputs, batch, *args, **kwargs)

Compute the loss of the model given outputs from forward() and a Batch of data from the dataloader. The Trainer will call .backward() on the returned loss.

Parameters

• outputs (Any) – The output of the forward pass.

• batch (Batch) – The output batch from dataloader.

Returns

Tensor | Sequence[Tensor] – The loss as a torch.Tensor.

Example:

import torch.nn.functional as F

def loss(self, outputs, batch):
    # pass batches and :meth:`forward` outputs to the loss
     _, targets = batch # discard inputs from batch
    return F.cross_entropy(outputs, targets)

The outputs of forward() are passed to loss() by the trainer:

for batch in train_dataloader:
    optimizer.zero_grad()
    outputs = model.forward(batch)
    loss = model.loss(outputs, batch)
    loss.backward()

update_metric(batch, outputs, metric)

Update the given metric.

Args:

batch: The dataloader batch outputs: The output from eval_forward() metric (Metric): The metric to update.

Returns

Optional[Dict] – Optionally return metric results to be stored in state.