Implementation:Snorkel team Snorkel Task Init

Knowledge Sources	Snorkel
Domains	Multi_Task_Learning, Computation_Graphs, PyTorch
Last Updated	2026-02-14 20:00 GMT

Overview

Concrete tool for defining task computation graphs using Operations and Tasks, provided by the Snorkel library.

Description

Operation specifies a single forward pass through a module, referencing inputs from previous operations or the raw input. Task bundles a module pool, operation sequence, loss function, output function, and scorer into a complete task definition for MultitaskClassifier.

Usage

Import these classes when configuring computation graphs for MultitaskClassifier.

Code Reference

Source Location

• Repository: snorkel
• File: snorkel/classification/task.py
• Lines: L14-126

Signature

class Operation:
    def __init__(
        self,
        module_name: str,
        inputs: Sequence[Union[str, Tuple[str, str]]],
        name: Optional[str] = None,
    ) -> None:
        """
        Args:
            module_name: Name of module in module_pool.
            inputs: Input sources - operation names or ("_input_", field_name) tuples.
            name: Operation name (defaults to module_name).
        """

class Task:
    def __init__(
        self,
        name: str,
        module_pool: nn.ModuleDict,
        op_sequence: Sequence[Operation],
        scorer: Scorer = Scorer(metrics=["accuracy"]),
        loss_func: Optional[Callable[..., torch.Tensor]] = None,
        output_func: Optional[Callable[..., torch.Tensor]] = None,
    ) -> None:
        """
        Args:
            name: Task name (must match Y_dict key).
            module_pool: Dict of named nn.Module instances.
            op_sequence: Ordered operations defining data flow.
            scorer: Evaluation scorer (default: accuracy).
            loss_func: Loss function (default: F.cross_entropy).
            output_func: Output function (default: F.softmax(dim=1)).
        """

Import

from snorkel.classification import Task, Operation

I/O Contract

Inputs

Name	Type	Required	Description
module_name	str	Yes	References a module in the module_pool
inputs	Sequence[Union[str, Tuple[str, str]]]	Yes	Input operation names or ("_input_", field) tuples
name (Task)	str	Yes	Task name matching Y_dict key
module_pool	nn.ModuleDict	Yes	Dictionary of nn.Module instances
op_sequence	Sequence[Operation]	Yes	Ordered operations for data flow

Outputs

Name	Type	Description
Task instance	Task	Complete task definition for MultitaskClassifier
Operation instance	Operation	Single computation step in the task graph

Usage Examples

import torch.nn as nn
from snorkel.classification import Task, Operation
from snorkel.analysis import Scorer

# Define modules
module_pool = nn.ModuleDict({
    "encoder": nn.Linear(100, 64),
    "relu": nn.ReLU(),
    "head": nn.Linear(64, 2),
})

# Define operation sequence: encoder -> relu -> head
op_sequence = [
    Operation(module_name="encoder", inputs=[("_input_", "features")]),
    Operation(module_name="relu", inputs=["encoder"]),
    Operation(module_name="head", inputs=["relu"]),
]

# Create task
task = Task(
    name="sentiment",
    module_pool=module_pool,
    op_sequence=op_sequence,
    scorer=Scorer(metrics=["accuracy", "f1"]),
)

Related Pages

Implements Principle

• Principle:Snorkel_team_Snorkel_Task_Operation_Definition