python_code
stringlengths 0
4.04M
| repo_name
stringlengths 8
58
| file_path
stringlengths 5
147
|
|---|---|---|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from classy_vision import meters
from classy_vision.meters import AccuracyMeter
from test.generic.meter_test_utils import ClassificationMeterTest
class TestAccuracyMeter(ClassificationMeterTest):
def test_accuracy_meter_registry(self):
accuracy_meter = meters.build_meter({"name": "accuracy", "topk": [1, 2]})
self.assertTrue(isinstance(accuracy_meter, AccuracyMeter))
def test_single_meter_update_and_reset(self):
"""
This test verifies that the meter works as expected on a single
update + reset + same single update.
"""
meter = AccuracyMeter(topk=[1, 2])
# Batchsize = 3, num classes = 3, score is a value in {1, 2,
# 3}...3 is the highest score
model_output = torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]])
# Class 0 is the correct class for sample 1, class 2 for sample 2, etc
target = torch.tensor([0, 1, 2])
# Only the first sample has top class correct, first and third
# sample have correct class in top 2
expected_value = {"top_1": 1 / 3.0, "top_2": 2 / 3.0}
self.meter_update_and_reset_test(meter, model_output, target, expected_value)
def test_double_meter_update_and_reset(self):
meter = AccuracyMeter(topk=[1, 2])
# Batchsize = 3, num classes = 3, score is a value in {1, 2,
# 3}...3 is the highest score...two batches in this test
model_outputs = [
torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]]),
torch.tensor([[3, 2, 1], [1, 3, 2], [1, 3, 2]]),
]
# Class 0 is the correct class for sample 1, class 2 for
# sample 2, etc, in both batches
targets = [torch.tensor([0, 1, 2]), torch.tensor([0, 1, 2])]
# First batch has top-1 accuracy of 1/3.0, top-2 accuracy of 2/3.0
# Second batch has top-1 accuracy of 2/3.0, top-2 accuracy of 3/3.0
expected_value = {"top_1": 3 / 6.0, "top_2": 5 / 6.0}
self.meter_update_and_reset_test(meter, model_outputs, targets, expected_value)
def test_single_meter_update_and_reset_onehot(self):
"""
This test verifies that the meter works as expected on a single
update + reset + same single update with onehot target.
"""
meter = AccuracyMeter(topk=[1, 2])
# Batchsize = 3, num classes = 3, score is a value in {1, 2,
# 3}...3 is the highest score
model_output = torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]])
# Class 0 is the correct class for sample 1, class 2 for sample 2, etc
target = torch.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
# Only the first sample has top class correct, first and third
# sample have correct class in top 2
expected_value = {"top_1": 1 / 3.0, "top_2": 2 / 3.0}
self.meter_update_and_reset_test(meter, model_output, target, expected_value)
def test_single_meter_update_and_reset_multilabel(self):
"""
This test verifies that the meter works as expected on a single
update + reset + same single update with multilabel target.
"""
meter = AccuracyMeter(topk=[1, 2])
# Batchsize = 7, num classes = 3, score is a value in {1, 2,
# 3}...3 is the highest score
model_output = torch.tensor(
[
[3, 2, 1],
[3, 1, 2],
[1, 3, 2],
[1, 2, 3],
[2, 1, 3],
[2, 3, 1],
[1, 3, 2],
]
)
target = torch.tensor(
[
[1, 1, 0],
[0, 0, 1],
[1, 0, 0],
[0, 0, 1],
[0, 1, 1],
[1, 1, 1],
[1, 0, 1],
]
)
# 1st, 4th, 5th, 6th sample has top class correct, 2nd and 7th have at least
# one correct class in top 2.
expected_value = {"top_1": 4 / 7.0, "top_2": 6 / 7.0}
self.meter_update_and_reset_test(meter, model_output, target, expected_value)
def test_meter_invalid_model_output(self):
meter = AccuracyMeter(topk=[1, 2])
# This model output has 3 dimensions instead of expected 2
model_output = torch.tensor(
[[[3, 2, 1], [1, 2, 3]], [[-1, -3, -4], [-10, -90, -100]]]
)
target = torch.tensor([0, 1, 2])
self.meter_invalid_meter_input_test(meter, model_output, target)
def test_meter_invalid_target(self):
meter = AccuracyMeter(topk=[1, 2])
model_output = torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]])
# Target has 3 dimensions instead of expected 1 or 2
target = torch.tensor([[[0, 1, 2], [0, 1, 2]]])
self.meter_invalid_meter_input_test(meter, model_output, target)
def test_meter_invalid_topk(self):
meter = AccuracyMeter(topk=[1, 5])
model_output = torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]])
target = torch.tensor([0, 1, 2])
self.meter_invalid_meter_input_test(meter, model_output, target)
def test_meter_get_set_classy_state_test(self):
# In this test we update meter0 with model_output0 & target0
# and we update meter1 with model_output1 & target1 then
# transfer the state from meter1 to meter0 and validate they
# give same expected value.
# Expected value is the expected value of meter1
meters = [AccuracyMeter(topk=[1, 2]), AccuracyMeter(topk=[1, 2])]
# Batchsize = 3, num classes = 3, score is a value in {1, 2,
# 3}...3 is the highest score
model_outputs = [
torch.tensor([[1, 2, 3], [1, 2, 3], [2, 3, 1]]),
torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]]),
]
# Class 0 is the correct class for sample 1, class 2 for sample 2, etc
targets = [torch.tensor([0, 1, 2]), torch.tensor([0, 1, 2])]
# Value for second update
expected_value = {"top_1": 1 / 3.0, "top_2": 2 / 3.0}
self.meter_get_set_classy_state_test(
meters, model_outputs, targets, expected_value
)
def test_meter_distributed(self):
# Meter0 will execute on one process, Meter1 on the other
meters = [AccuracyMeter(topk=[1, 2]), AccuracyMeter(topk=[1, 2])]
# Batchsize = 3, num classes = 3, score is a value in {1, 2,
# 3}...3 is the highest score
model_outputs = [
torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]]), # Meter 0
torch.tensor([[3, 2, 1], [1, 3, 2], [1, 3, 2]]), # Meter 1
torch.tensor([[3, 2, 1], [3, 1, 2], [1, 3, 2]]), # Meter 0
torch.tensor([[3, 2, 1], [1, 3, 2], [1, 3, 2]]), # Meter 1
]
# Class 0 is the correct class for sample 1, class 2 for sample 2, etc
targets = [
torch.tensor([0, 1, 2]), # Meter 0
torch.tensor([0, 1, 2]), # Meter 1
torch.tensor([0, 1, 2]), # Meter 0
torch.tensor([0, 1, 2]), # Meter 1
]
# In first two updates there are 3 correct top-2, 5 correct in top 2
# The same occurs in the second two updates and is added to first
expected_values = [
{"top_1": 3 / 6.0, "top_2": 5 / 6.0}, # After one update to each meter
{"top_1": 6 / 12.0, "top_2": 10 / 12.0}, # After two updates to each meter
]
self.meter_distributed_test(meters, model_outputs, targets, expected_values)
|
ClassyVision-main
|
test/meters_accuracy_meter_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
from functools import partial
import torch
from classy_vision.generic.util import get_torch_version
from classy_vision.heads import build_head
from classy_vision.heads.fully_connected_head import FullyConnectedHead
from test.generic.utils import ClassyTestCase
class TestFullyConnectedHead(ClassyTestCase):
def test_fully_connected_head(self):
batch_size = 2
in_plane = 3
image_size = 4
num_classes = 5
head = FullyConnectedHead(
"default_head",
num_classes=num_classes,
in_plane=in_plane,
)
input = torch.rand([batch_size, in_plane, image_size, image_size])
output = head(input)
self.assertEqual(output.shape, torch.Size([batch_size, num_classes]))
def test_fully_connected_head_normalize_inputs(self):
batch_size = 2
in_plane = 3
image_size = 4
head = FullyConnectedHead(
"default_head",
in_plane=in_plane,
normalize_inputs="l2",
num_classes=None,
)
input = torch.rand([batch_size, in_plane, image_size, image_size])
output = head(input)
self.assertEqual(output.shape, torch.Size([batch_size, in_plane]))
for i in range(batch_size):
output_i = output[i]
self.assertAlmostEqual(output_i.norm().item(), 1, delta=1e-5)
# test that the grads will be the same when using normalization as when
# normalizing an input and passing it to the head without normalize_inputs.
# use input with a norm > 1 and make image_size = 1 so that average
# pooling is a no op
image_size = 1
input = 2 + torch.rand([batch_size, in_plane, image_size, image_size])
norm_func = (
torch.linalg.norm
if get_torch_version() >= [1, 7]
else partial(torch.norm, p=2)
)
norms = norm_func(input.view(batch_size, -1), dim=1)
normalized_input = torch.clone(input)
for i in range(batch_size):
normalized_input[i] /= norms[i]
num_classes = 10
head_norm = FullyConnectedHead(
"default_head",
in_plane=in_plane,
normalize_inputs="l2",
num_classes=num_classes,
)
head_no_norm = FullyConnectedHead(
"default_head",
in_plane=in_plane,
num_classes=num_classes,
)
# share the weights between the heads
head_norm.load_state_dict(copy.deepcopy(head_no_norm.state_dict()))
# use the sum of the output as the loss and perform a backward
head_no_norm(normalized_input).sum().backward()
head_norm(input).sum().backward()
for param_1, param_2 in zip(head_norm.parameters(), head_no_norm.parameters()):
self.assertTorchAllClose(param_1, param_2)
self.assertTorchAllClose(param_1.grad, param_2.grad)
def test_conv_planes(self):
num_classes = 10
in_plane = 3
conv_planes = 5
batch_size = 2
image_size = 4
head_config = {
"name": "fully_connected",
"unique_id": "asd",
"in_plane": in_plane,
"conv_planes": conv_planes,
"num_classes": num_classes,
}
head = build_head(head_config)
self.assertIsInstance(head, FullyConnectedHead)
# specify an activation
head_config["activation"] = "relu"
head = build_head(head_config)
# make sure that the head runs and returns the expected dimensions
input = torch.rand([batch_size, in_plane, image_size, image_size])
output = head(input)
self.assertEqual(output.shape, (batch_size, num_classes))
|
ClassyVision-main
|
test/heads_fully_connected_head_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.optim.param_scheduler import LinearParamScheduler
from classy_vision.optim.sgd import SGD
from test.generic.optim_test_util import TestOptimizer
class TestSGDOptimizer(TestOptimizer, unittest.TestCase):
def _get_config(self):
return {
"name": "sgd",
"num_epochs": 90,
"lr": 0.1,
"momentum": 0.9,
"weight_decay": 0.0001,
"nesterov": False,
}
def _instance_to_test(self):
return SGD
# This test relies on the SGD update equations, which is why it's not in
# the base class TestOptimizer
def test_lr_step(self):
opt = SGD()
param = torch.tensor([0.0], requires_grad=True)
opt.set_param_groups([param], lr=LinearParamScheduler(1, 2))
param.grad = torch.tensor([1.0])
self.assertAlmostEqual(opt.options_view.lr, 1.0)
# lr=1, param should go from 0 to -1
opt.step(where=0)
self.assertAlmostEqual(opt.options_view.lr, 1.0)
self.assertAlmostEqual(param.item(), -1.0, delta=1e-5)
# lr=1.5, param should go from -1 to -1-1.5 = -2.5
opt.step(where=0.5)
self.assertAlmostEqual(param.item(), -2.5, delta=1e-5)
# lr=1.9, param should go from -2.5 to -1.9-2.5 = -4.4
opt.step(where=0.9)
self.assertAlmostEqual(param.item(), -4.4, delta=1e-5)
|
ClassyVision-main
|
test/optim_sgd_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import itertools
import shutil
import tempfile
import unittest
import torch
import torch.nn as nn
from classy_vision.dataset import build_dataset
from classy_vision.generic.distributed_util import is_distributed_training_run
from classy_vision.generic.util import get_checkpoint_dict, get_torch_version
from classy_vision.hooks import CheckpointHook, LossLrMeterLoggingHook
from classy_vision.losses import build_loss, ClassyLoss, register_loss
from classy_vision.models import build_model, ClassyModel
from classy_vision.optim import build_optimizer, SGD
from classy_vision.tasks import build_task, ClassificationTask
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_fast_test_task_config, get_test_task_config
from test.generic.utils import (
compare_model_state,
compare_samples,
compare_states,
LimitedPhaseTrainer,
)
@register_loss("test_stateful_loss")
class TestStatefulLoss(ClassyLoss):
def __init__(self, in_plane):
super(TestStatefulLoss, self).__init__()
self.alpha = torch.nn.Parameter(torch.Tensor(in_plane, 2))
torch.nn.init.xavier_normal(self.alpha)
@classmethod
def from_config(cls, config) -> "TestStatefulLoss":
return cls(in_plane=config["in_plane"])
def forward(self, output, target):
value = output.matmul(self.alpha)
loss = torch.mean(torch.abs(value))
return loss
# Generate a simple model that has a very high gradient w.r.t. to this
# loss
class SimpleModel(ClassyModel):
def __init__(self):
super().__init__()
self.param = nn.Parameter(torch.tensor(5.0), requires_grad=True)
def forward(self, x):
return x + self.param
@classmethod
def from_config(cls):
return cls()
class SimpleLoss(nn.Module):
def forward(self, x, y):
return x.pow(2).mean()
class TestClassificationTask(unittest.TestCase):
def _compare_model_state(self, model_state_1, model_state_2, check_heads=True):
compare_model_state(self, model_state_1, model_state_2, check_heads)
def _compare_samples(self, sample_1, sample_2):
compare_samples(self, sample_1, sample_2)
def _compare_states(self, state_1, state_2, check_heads=True):
compare_states(self, state_1, state_2)
def setUp(self):
# create a base directory to write checkpoints to
self.base_dir = tempfile.mkdtemp()
def tearDown(self):
# delete all the temporary data created
shutil.rmtree(self.base_dir)
def test_build_task(self):
config = get_test_task_config()
task = build_task(config)
self.assertTrue(isinstance(task, ClassificationTask))
def test_hooks_config_builds_correctly(self):
config = get_test_task_config()
config["hooks"] = [{"name": "loss_lr_meter_logging"}]
task = build_task(config)
self.assertTrue(len(task.hooks) == 1)
self.assertTrue(isinstance(task.hooks[0], LossLrMeterLoggingHook))
def test_get_state(self):
config = get_test_task_config()
loss = build_loss(config["loss"])
task = (
ClassificationTask()
.set_num_epochs(1)
.set_loss(loss)
.set_model(build_model(config["model"]))
.set_optimizer(build_optimizer(config["optimizer"]))
)
for phase_type in ["train", "test"]:
dataset = build_dataset(config["dataset"][phase_type])
task.set_dataset(dataset, phase_type)
task.prepare()
task = build_task(config)
task.prepare()
def test_synchronize_losses_non_distributed(self):
"""
Tests that synchronize losses has no side effects in a non-distributed setting.
"""
test_config = get_fast_test_task_config()
task = build_task(test_config)
task.prepare()
old_losses = copy.deepcopy(task.losses)
task.synchronize_losses()
self.assertEqual(old_losses, task.losses)
def test_synchronize_losses_when_losses_empty(self):
config = get_fast_test_task_config()
task = build_task(config)
task.prepare()
task.set_use_gpu(torch.cuda.is_available())
# Losses should be empty when creating task
self.assertEqual(len(task.losses), 0)
task.synchronize_losses()
def test_checkpointing(self):
"""
Tests checkpointing by running train_steps to make sure the train_steps
run the same way after loading from a checkpoint.
"""
config = get_fast_test_task_config()
task = build_task(config).set_hooks([LossLrMeterLoggingHook()])
task_2 = build_task(config).set_hooks([LossLrMeterLoggingHook()])
task.set_use_gpu(torch.cuda.is_available())
# only train 1 phase at a time
trainer = LimitedPhaseTrainer(num_phases=1)
while not task.done_training():
# set task's state as task_2's checkpoint
task_2._set_checkpoint_dict(get_checkpoint_dict(task, {}, deep_copy=True))
# task 2 should have the same state before training
self._compare_states(task.get_classy_state(), task_2.get_classy_state())
# train for one phase
trainer.train(task)
trainer.train(task_2)
# task 2 should have the same state after training
self._compare_states(task.get_classy_state(), task_2.get_classy_state())
def test_final_train_checkpoint(self):
"""Test that a train phase checkpoint with a where of 1.0 can be loaded"""
config = get_fast_test_task_config()
task = build_task(config).set_hooks(
[CheckpointHook(self.base_dir, {}, phase_types=["train"])]
)
task_2 = build_task(config)
task.set_use_gpu(torch.cuda.is_available())
trainer = LocalTrainer()
trainer.train(task)
self.assertAlmostEqual(task.where, 1.0, delta=1e-3)
# set task_2's state as task's final train checkpoint
task_2.set_checkpoint(self.base_dir)
task_2.prepare()
# we should be able to train the task
trainer.train(task_2)
def test_test_only_checkpointing(self):
"""
Tests checkpointing by running train_steps to make sure the
train_steps run the same way after loading from a training
task checkpoint on a test_only task.
"""
train_config = get_fast_test_task_config()
train_config["num_epochs"] = 10
test_config = get_fast_test_task_config()
test_config["test_only"] = True
train_task = build_task(train_config).set_hooks([LossLrMeterLoggingHook()])
test_only_task = build_task(test_config).set_hooks([LossLrMeterLoggingHook()])
# prepare the tasks for the right device
train_task.prepare()
# test in both train and test mode
trainer = LocalTrainer()
trainer.train(train_task)
# set task's state as task_2's checkpoint
test_only_task._set_checkpoint_dict(
get_checkpoint_dict(train_task, {}, deep_copy=True)
)
test_only_task.prepare()
test_state = test_only_task.get_classy_state()
# We expect the phase idx to be different for a test only task
self.assertEqual(test_state["phase_idx"], -1)
# We expect that test only state is test, no matter what train state is
self.assertFalse(test_state["train"])
# Num updates should be 0
self.assertEqual(test_state["num_updates"], 0)
# train_phase_idx should -1
self.assertEqual(test_state["train_phase_idx"], -1)
# Verify task will run
trainer = LocalTrainer()
trainer.train(test_only_task)
def test_test_only_task(self):
"""
Tests the task in test mode by running train_steps
to make sure the train_steps run as expected on a
test_only task
"""
test_config = get_fast_test_task_config()
test_config["test_only"] = True
# delete train dataset
del test_config["dataset"]["train"]
test_only_task = build_task(test_config).set_hooks([LossLrMeterLoggingHook()])
test_only_task.prepare()
test_state = test_only_task.get_classy_state()
# We expect that test only state is test, no matter what train state is
self.assertFalse(test_state["train"])
# Num updates should be 0
self.assertEqual(test_state["num_updates"], 0)
# Verify task will run
trainer = LocalTrainer()
trainer.train(test_only_task)
def test_train_only_task(self):
"""
Tests that the task runs when only a train dataset is specified.
"""
test_config = get_fast_test_task_config()
# delete the test dataset from the config
del test_config["dataset"]["test"]
task = build_task(test_config).set_hooks([LossLrMeterLoggingHook()])
task.prepare()
# verify the the task can still be trained
trainer = LocalTrainer()
trainer.train(task)
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_checkpointing_different_device(self):
config = get_fast_test_task_config()
task = build_task(config)
task_2 = build_task(config)
for use_gpu in [True, False]:
task.set_use_gpu(use_gpu)
task.prepare()
# set task's state as task_2's checkpoint
task_2._set_checkpoint_dict(get_checkpoint_dict(task, {}, deep_copy=True))
# we should be able to run the trainer using state from a different device
trainer = LocalTrainer()
task_2.set_use_gpu(not use_gpu)
trainer.train(task_2)
@unittest.skipUnless(
is_distributed_training_run(), "This test needs a distributed run"
)
def test_get_classy_state_on_loss(self):
config = get_fast_test_task_config()
config["loss"] = {"name": "test_stateful_loss", "in_plane": 256}
task = build_task(config)
task.prepare()
self.assertIn("alpha", task.get_classy_state()["loss"])
def test_gradient_clipping(self):
apex_available = True
try:
import apex # noqa F401
except ImportError:
apex_available = False
def train_with_clipped_gradients(amp_args=None):
task = build_task(get_fast_test_task_config())
task.set_num_epochs(1)
task.set_model(SimpleModel())
task.set_loss(SimpleLoss())
task.set_meters([])
task.set_use_gpu(torch.cuda.is_available())
task.set_clip_grad_norm(0.5)
task.set_amp_args(amp_args)
task.set_optimizer(SGD(lr=1))
trainer = LocalTrainer()
trainer.train(task)
return task.model.param.grad.norm()
grad_norm = train_with_clipped_gradients(None)
self.assertAlmostEqual(grad_norm, 0.5, delta=1e-2)
if apex_available and torch.cuda.is_available():
grad_norm = train_with_clipped_gradients({"opt_level": "O2"})
self.assertAlmostEqual(grad_norm, 0.5, delta=1e-2)
def test_clip_stateful_loss(self):
config = get_fast_test_task_config()
config["loss"] = {"name": "test_stateful_loss", "in_plane": 256}
config["grad_norm_clip"] = grad_norm_clip = 1
task = build_task(config)
task.set_use_gpu(False)
task.prepare()
# set fake gradients with norm > grad_norm_clip
for param in itertools.chain(
task.base_model.parameters(), task.base_loss.parameters()
):
param.grad = 1.1 + torch.rand(param.shape)
self.assertGreater(param.grad.norm(), grad_norm_clip)
task._clip_gradients(grad_norm_clip)
for param in itertools.chain(
task.base_model.parameters(), task.base_loss.parameters()
):
self.assertLessEqual(param.grad.norm(), grad_norm_clip)
# helper used by gradient accumulation tests
def train_with_batch(self, simulated_bs, actual_bs, clip_grad_norm=None):
config = copy.deepcopy(get_fast_test_task_config())
config["dataset"]["train"]["num_samples"] = 12
config["dataset"]["train"]["batchsize_per_replica"] = actual_bs
del config["dataset"]["test"]
task = build_task(config)
task.set_num_epochs(1)
task.set_model(SimpleModel())
task.set_loss(SimpleLoss())
task.set_meters([])
task.set_use_gpu(torch.cuda.is_available())
if simulated_bs is not None:
task.set_simulated_global_batchsize(simulated_bs)
if clip_grad_norm is not None:
task.set_clip_grad_norm(clip_grad_norm)
task.set_optimizer(SGD(lr=1))
trainer = LocalTrainer()
trainer.train(task)
return task.model.param
def test_gradient_accumulation(self):
param_with_accumulation = self.train_with_batch(simulated_bs=4, actual_bs=2)
param = self.train_with_batch(simulated_bs=4, actual_bs=4)
self.assertAlmostEqual(param_with_accumulation, param, delta=1e-5)
def test_gradient_accumulation_and_clipping(self):
param = self.train_with_batch(simulated_bs=6, actual_bs=2, clip_grad_norm=0.1)
# param starts at 5, it has to decrease, LR = 1
# clipping the grad to 0.1 means we drop 0.1 per update. num_samples =
# 12 and the simulated batch size is 6, so we should do 2 updates: 5 ->
# 4.9 -> 4.8
self.assertAlmostEqual(param, 4.8, delta=1e-5)
@unittest.skipIf(
get_torch_version() < [1, 8],
"FP16 Grad compression is only available from PyTorch 1.8",
)
def test_fp16_grad_compression(self):
# there is no API defined to check that a DDP hook has been enabled, so we just
# test that we set the right variables
config = copy.deepcopy(get_fast_test_task_config())
task = build_task(config)
self.assertFalse(task.fp16_grad_compress)
config.setdefault("distributed", {})
config["distributed"]["fp16_grad_compress"] = True
task = build_task(config)
self.assertTrue(task.fp16_grad_compress)
|
ClassyVision-main
|
test/tasks_classification_task_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
StepParamScheduler,
)
class TestStepScheduler(unittest.TestCase):
_num_epochs = 12
def _get_valid_config(self):
return {
"name": "step",
"num_epochs": self._num_epochs,
"values": [0.1, 0.01, 0.001, 0.0001],
}
def test_invalid_config(self):
# Invalid num epochs
config = self._get_valid_config()
bad_config = copy.deepcopy(config)
bad_config["num_epochs"] = -1
with self.assertRaises(ValueError):
StepParamScheduler.from_config(bad_config)
# Invalid Values
bad_config["num_epochs"] = config["num_epochs"]
del bad_config["values"]
with self.assertRaises(TypeError):
StepParamScheduler.from_config(bad_config)
bad_config["values"] = {"a": "b"}
with self.assertRaises(ValueError):
StepParamScheduler.from_config(bad_config)
bad_config["values"] = []
with self.assertRaises(ValueError):
StepParamScheduler.from_config(bad_config)
def test_scheduler(self):
config = self._get_valid_config()
scheduler = StepParamScheduler.from_config(config)
schedule = [
scheduler(epoch_num / self._num_epochs)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [
0.1,
0.1,
0.1,
0.01,
0.01,
0.01,
0.001,
0.001,
0.001,
0.0001,
0.0001,
0.0001,
]
self.assertEqual(schedule, expected_schedule)
def test_build_step_scheduler(self):
config = self._get_valid_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, StepParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_step_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import torch
import torchvision.transforms._transforms_video as transforms_video
from classy_vision.dataset.core.random_video_datasets import RandomVideoDataset
from classy_vision.dataset.transforms.util_video import (
build_video_field_transform_default,
VideoConstants,
)
class DatasetTransformUtilVideoTest(unittest.TestCase):
def get_test_video_dataset(self):
self.num_classes = 10
self.split = "train"
self.num_samples = 100
self.frames_per_clip = 32
self.video_width = 320
self.video_height = 256
self.audio_samples = 44000
self.clips_per_video = 1
self.seed = 1
dataset = RandomVideoDataset(
self.num_classes,
self.split,
self.num_samples,
self.frames_per_clip,
self.video_width,
self.video_height,
self.audio_samples,
self.clips_per_video,
self.seed,
)
return dataset
def test_build_field_transform_default_video(self):
dataset = self.get_test_video_dataset()
# transform config is not provided. Use default transforms
config = None
# default training data transform
sample = dataset[0]
transform = build_video_field_transform_default(config, "train")
output_clip = transform(sample)["input"]["video"]
self.assertEqual(
output_clip.size(),
torch.Size(
(
3,
self.frames_per_clip,
VideoConstants.CROP_SIZE,
VideoConstants.CROP_SIZE,
)
),
)
# default testing data transform
sample = dataset[1]
sample_copy = copy.deepcopy(sample)
expected_output_clip = transforms_video.ToTensorVideo()(
sample["input"]["video"]
)
expected_output_clip = transforms_video.CenterCropVideo(
VideoConstants.CROP_SIZE
)(expected_output_clip)
expected_output_clip = transforms_video.NormalizeVideo(
mean=VideoConstants.MEAN, std=VideoConstants.STD
)(expected_output_clip)
transform = build_video_field_transform_default(config, "test")
output_clip = transform(sample_copy)["input"]["video"]
rescaled_width = int(
VideoConstants.SIZE_RANGE[0] * self.video_width / self.video_height
)
self.assertEqual(
output_clip.size(),
torch.Size(
(3, self.frames_per_clip, VideoConstants.SIZE_RANGE[0], rescaled_width)
),
)
# transform config is provided. Simulate training config
sample = dataset[2]
config = {
"video": [
{"name": "ToTensorVideo"},
{
"name": "video_clip_random_resize_crop",
"crop_size": 64,
"size_range": [256, 320],
},
{"name": "RandomHorizontalFlipVideo"},
{
"name": "NormalizeVideo",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
]
}
transform = build_video_field_transform_default(config, "train")
output_clip = transform(sample)["input"]["video"]
self.assertEqual(
output_clip.size(), torch.Size((3, self.frames_per_clip, 64, 64))
)
self.assertTrue(output_clip.dtype == torch.float)
# transform config is provided. Simulate testing config
sample = dataset[3]
config = {
"video": [
{"name": "ToTensorVideo"},
{"name": "video_clip_resize", "size": 64},
{
"name": "NormalizeVideo",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
]
}
transform = build_video_field_transform_default(config, "train")
output_clip = transform(sample)["input"]["video"]
rescaled_width = int(64 * self.video_width / self.video_height)
self.assertEqual(
output_clip.size(),
torch.Size((3, self.frames_per_clip, 64, rescaled_width)),
)
self.assertTrue(output_clip.dtype == torch.float)
|
ClassyVision-main
|
test/dataset_transforms_util_video_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
MultiStepParamScheduler,
)
class TestMultiStepParamScheduler(unittest.TestCase):
_num_epochs = 12
def _get_valid_config(self):
return {
"name": "multistep",
"num_epochs": self._num_epochs,
"values": [0.1, 0.01, 0.001, 0.0001],
"milestones": [4, 6, 8],
}
def test_invalid_config(self):
# Invalid num epochs
config = self._get_valid_config()
bad_config = copy.deepcopy(config)
bad_config["num_epochs"] = -1
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
# Invalid values
bad_config["num_epochs"] = config["num_epochs"]
del bad_config["values"]
with self.assertRaises((AssertionError, TypeError)):
MultiStepParamScheduler.from_config(bad_config)
bad_config["values"] = {"a": "b"}
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
bad_config["values"] = []
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
# Invalid drop epochs
bad_config["values"] = config["values"]
bad_config["milestones"] = {"a": "b"}
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
# Too many
bad_config["milestones"] = [3, 6, 8, 12]
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
# Too few
bad_config["milestones"] = [3, 6]
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
# Exceeds num_epochs
bad_config["milestones"] = [3, 6, 12]
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
# Out of order
bad_config["milestones"] = [3, 8, 6]
with self.assertRaises(ValueError):
MultiStepParamScheduler.from_config(bad_config)
def _test_config_scheduler(self, config, expected_schedule):
scheduler = MultiStepParamScheduler.from_config(config)
schedule = [
scheduler(epoch_num / self._num_epochs)
for epoch_num in range(self._num_epochs)
]
self.assertEqual(schedule, expected_schedule)
def test_scheduler(self):
config = self._get_valid_config()
expected_schedule = [
0.1,
0.1,
0.1,
0.1,
0.01,
0.01,
0.001,
0.001,
0.0001,
0.0001,
0.0001,
0.0001,
]
self._test_config_scheduler(config, expected_schedule)
def test_default_config(self):
config = self._get_valid_config()
default_config = copy.deepcopy(config)
# Default equispaced drop_epochs behavior
del default_config["milestones"]
expected_schedule = [
0.1,
0.1,
0.1,
0.01,
0.01,
0.01,
0.001,
0.001,
0.001,
0.0001,
0.0001,
0.0001,
]
self._test_config_scheduler(default_config, expected_schedule)
def test_build_non_equi_step_scheduler(self):
config = self._get_valid_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, MultiStepParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_multi_step_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import logging
import unittest
import torch
import torch.nn as nn
from classy_vision.generic.util import get_torch_version
from classy_vision.models import build_model, RegNet
from parameterized import parameterized
# Test the different exposed parameters, even if not present in the
# actual checked in configurations
REGNET_TEST_CONFIGS = [
(
{
# RegNetY
"name": "regnet",
"bn_epsilon": 1e-05, # optional
"bn_momentum": 0.1, # optional
"stem_type": "simple_stem_in", # optional
"stem_width": 32, # optional
"block_type": "res_bottleneck_block", # optional
"depth": 22,
"w_0": 24,
"w_a": 24.48,
"w_m": 2.54,
"group_width": 16,
"use_se": True, # optional
"se_ratio": 0.25, # optional
},
),
(
{
# RegNetX-like (no se)
"name": "regnet",
"depth": 22,
"w_0": 24,
"w_a": 24.48,
"w_m": 2.54,
"group_width": 16,
"use_se": False, # optional
},
),
(
{
# RegNetY, different block
"name": "regnet",
"depth": 22,
"w_0": 24,
"w_a": 24.48,
"w_m": 2.54,
"group_width": 16,
"block_type": "vanilla_block", # optional
},
),
(
{
# RegNetY, different block
"name": "regnet",
"depth": 22,
"w_0": 24,
"w_a": 24.48,
"w_m": 2.54,
"group_width": 16,
"block_type": "res_basic_block", # optional
},
),
(
{
# RegNetY, different stem
"name": "regnet",
"depth": 22,
"w_0": 24,
"w_a": 24.48,
"w_m": 2.54,
"group_width": 16,
"stem_type": "res_stem_cifar", # optional
},
),
(
{
# RegNetY, different stem
"name": "regnet",
"depth": 22,
"w_0": 24,
"w_a": 24.48,
"w_m": 2.54,
"group_width": 16,
"stem_type": "res_stem_in", # optional
},
),
(
{
# Default minimal param set
"name": "regnet",
"depth": 17,
"w_0": 192,
"w_a": 76.82,
"w_m": 2.19,
"group_width": 56,
},
),
(
{
# RegNetZ
"name": "regnet",
"block_type": "res_bottleneck_linear_block",
"depth": 21,
"w_0": 16,
"w_a": 10.7,
"w_m": 2.51,
"group_width": 4,
"bot_mul": 4.0,
"activation": "silu",
},
),
]
REGNET_TEST_PRESET_NAMES = [
"regnet_y_400mf",
"regnet_y_800mf",
"regnet_y_1.6gf",
"regnet_y_3.2gf",
"regnet_y_8gf",
"regnet_y_16gf",
"regnet_y_32gf",
"regnet_y_64gf",
"regnet_y_128gf",
"regnet_y_256gf",
"regnet_x_400mf",
"regnet_x_800mf",
"regnet_x_1.6gf",
"regnet_x_3.2gf",
"regnet_x_8gf",
"regnet_x_16gf",
"regnet_x_32gf",
"regnet_z_500mf",
"regnet_z_4gf",
]
REGNET_TEST_PRESETS = [({"name": n},) for n in REGNET_TEST_PRESET_NAMES]
class TestRegNetModelBuild(unittest.TestCase):
@parameterized.expand(REGNET_TEST_CONFIGS + REGNET_TEST_PRESETS)
def test_build_model(self, config):
"""
Test that the model builds using a config using either model_params or
model_name.
"""
if get_torch_version() < [1, 7] and (
"regnet_z" in config["name"] or config.get("activation", "relu") == "silu"
):
self.skipTest("SiLU activation is only supported since PyTorch 1.7")
model = build_model(config)
assert isinstance(model, RegNet)
@parameterized.expand(REGNET_TEST_CONFIGS + REGNET_TEST_PRESETS)
def test_quantize_model(self, config):
"""
Test that the model builds using a config using either model_params or
model_name and calls fx graph mode quantization apis
"""
if get_torch_version() < [1, 13]:
self.skipTest(
"This test is using a new api of FX Graph Mode Quantization which is only available after 1.13"
)
import torch.ao.quantization as tq
from torch.ao.quantization.quantize_fx import convert_fx, prepare_fx
model = build_model(config)
assert isinstance(model, RegNet)
model.eval()
example_inputs = (torch.rand(1, 3, 3, 3),)
model.stem = prepare_fx(model.stem, {"": tq.default_qconfig}, example_inputs)
model.stem = convert_fx(model.stem)
class TestRegNetModelFW(unittest.TestCase):
@parameterized.expand(
[({"name": n},) for n in ["regnet_y_400mf", "regnet_x_400mf"]]
)
def test_model_forward(self, config):
"""
Test that a default forward pass succeeds and does something
"""
image_shape = (3, 224, 224)
num_images = (10,)
input_tensor = torch.randn(num_images + image_shape)
model = build_model(config)
output = model.forward(input_tensor)
# Just check that this tensor actually went through a forward
# pass of sorts, and was not somehow bounced back
logging.info(f"Model {config}: output shape {output.shape}")
assert output.shape[0] == num_images[0]
# Default presets output 7x7 feature maps for 224x224 inputs
assert output.shape[-1] == 7
assert output.shape[-2] == 7
class TestRegNet(unittest.TestCase):
def _compare_models(self, model_1, model_2, expect_same: bool):
if expect_same:
self.assertMultiLineEqual(repr(model_1), repr(model_2))
else:
self.assertNotEqual(repr(model_1), repr(model_2))
def swap_relu_with_silu(self, module):
for child_name, child in module.named_children():
if isinstance(child, nn.ReLU):
setattr(module, child_name, nn.SiLU())
else:
self.swap_relu_with_silu(child)
def _check_no_module_cls_in_model(self, module_cls, model):
for module in model.modules():
self.assertNotIsInstance(module, module_cls)
@unittest.skipIf(
get_torch_version() < [1, 7],
"SiLU activation is only supported since PyTorch 1.7",
)
def test_activation(self):
config = REGNET_TEST_CONFIGS[0][0]
model_default = build_model(config)
config = copy.deepcopy(config)
config["activation"] = "relu"
model_relu = build_model(config)
# both models should be the same
self._compare_models(model_default, model_relu, expect_same=True)
# we don't expect any silus in the model
self._check_no_module_cls_in_model(nn.SiLU, model_relu)
config["activation"] = "silu"
model_silu = build_model(config)
# the models should be different
self._compare_models(model_silu, model_relu, expect_same=False)
# swap out all relus with silus
self.swap_relu_with_silu(model_relu)
print(model_relu)
# both models should be the same
self._compare_models(model_relu, model_silu, expect_same=True)
# we don't expect any relus in the model
self._check_no_module_cls_in_model(nn.ReLU, model_relu)
|
ClassyVision-main
|
test/models_regnet_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.dataset import build_dataset, register_dataset
from classy_vision.dataset.classy_video_dataset import (
ClassyVideoDataset,
MaxLengthClipSampler,
)
from classy_vision.dataset.core import ListDataset
from classy_vision.dataset.transforms.util_video import (
build_video_field_transform_default,
)
from torch.utils.data import Sampler
DUMMY_SAMPLES_1 = [
{
"input": {
"video": torch.randint(0, 256, (8, 3, 128, 128), dtype=torch.uint8),
"audio": torch.rand(1000, 1, dtype=torch.float32),
},
"target": torch.tensor([[0]]),
}
]
DUMMY_CONFIG = {
"name": "test_video_dataset",
"split": "train",
"batchsize_per_replica": 1,
"use_shuffle": True,
"num_samples": 1,
"frames_per_clip": 8,
"video_dir": "dummy_video_dir",
}
class MockClipSampler(Sampler):
def __init__(self, full_size=1000):
self.full_size = full_size
def __iter__(self):
indices = list(range(self.full_size))
return iter(indices)
def __len__(self):
return self.full_size
@register_dataset("test_video_dataset")
class TestVideoDataset(ClassyVideoDataset):
"""Test dataset for validating registry functions"""
def __init__(
self,
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
clips_per_video,
samples,
):
self.samples = samples
input_tensors = [sample["input"] for sample in samples]
target_tensors = [sample["target"] for sample in samples]
dataset = ListDataset(input_tensors, target_tensors, loader=lambda x: x)
super(TestVideoDataset, self).__init__(
dataset,
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
clips_per_video,
)
@classmethod
def from_config(cls, config, samples):
split = config.get("split")
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
step_between_clips,
frame_rate,
clips_per_video,
) = cls.parse_config(config)
transform = build_video_field_transform_default(transform_config, split)
return cls(
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
clips_per_video,
samples,
)
class TestRegistryFunctions(unittest.TestCase):
"""
Tests functions that use registry
"""
def test_build_dataset(self):
dataset = build_dataset(DUMMY_CONFIG, DUMMY_SAMPLES_1)
self.assertTrue(isinstance(dataset, TestVideoDataset))
class TestClassyVideoDataset(unittest.TestCase):
"""
Tests member functions of ClassyVideoDataset.
"""
def setUp(self):
self.dataset = build_dataset(DUMMY_CONFIG, DUMMY_SAMPLES_1)
def test_parse_config(self):
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
step_between_clips,
frame_rate,
clips_per_video,
) = self.dataset.parse_config(DUMMY_CONFIG)
def test_max_length_clip_sampler(self):
clip_sampler = MockClipSampler(full_size=1000)
clip_sampler = MaxLengthClipSampler(clip_sampler, num_samples=64)
count = 0
for _clip_index in iter(clip_sampler):
count += 1
self.assertEqual(count, 64)
self.assertEqual(len(clip_sampler), 64)
|
ClassyVision-main
|
test/dataset_classy_video_dataset_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import csv
import os
import shutil
import tempfile
import torch
from classy_vision.hooks import OutputCSVHook
from classy_vision.tasks import build_task
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_fast_test_task_config
from test.generic.hook_test_utils import HookTestBase
def parse_csv(file_path):
"""Parses the csv file and returns number of rows"""
num_rows = 0
with open(file_path, "r", newline="") as csvfile:
reader = csv.DictReader(csvfile, delimiter="\t")
for _ in reader:
num_rows += 1
return num_rows
class TestCSVHook(HookTestBase):
def setUp(self) -> None:
self.base_dir = tempfile.mkdtemp()
def tearDown(self) -> None:
shutil.rmtree(self.base_dir)
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
folder = f"{self.base_dir}/constructor_test/"
os.makedirs(folder)
self.constructor_test_helper(
config={"folder": folder},
hook_type=OutputCSVHook,
hook_registry_name="output_csv",
invalid_configs=[],
)
def test_train(self) -> None:
for use_gpu in {False, torch.cuda.is_available()}:
folder = f"{self.base_dir}/train_test/{use_gpu}"
os.makedirs(folder)
task = build_task(get_fast_test_task_config(head_num_classes=2))
csv_hook = OutputCSVHook(folder)
task.set_hooks([csv_hook])
task.set_use_gpu(use_gpu)
trainer = LocalTrainer()
trainer.train(task)
self.assertEqual(parse_csv(csv_hook.output_path), 10)
|
ClassyVision-main
|
test/hooks_output_csv_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
PolynomialDecayParamScheduler,
)
class TestPolynomialScheduler(unittest.TestCase):
_num_epochs = 10
def _get_valid_config(self):
return {
"name": "polynomial",
"num_epochs": self._num_epochs,
"base_value": 0.1,
"power": 1,
}
def test_invalid_config(self):
# Invalid num epochs
config = self._get_valid_config()
# Invalid Base lr
bad_config = copy.deepcopy(config)
del bad_config["base_value"]
with self.assertRaises((AssertionError, TypeError)):
PolynomialDecayParamScheduler.from_config(bad_config)
# Invalid Power
bad_config = copy.deepcopy(config)
del bad_config["power"]
with self.assertRaises((AssertionError, TypeError)):
PolynomialDecayParamScheduler.from_config(bad_config)
def test_scheduler(self):
config = self._get_valid_config()
scheduler = PolynomialDecayParamScheduler.from_config(config)
schedule = [
round(scheduler(epoch_num / self._num_epochs), 2)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [0.1, 0.09, 0.08, 0.07, 0.06, 0.05, 0.04, 0.03, 0.02, 0.01]
self.assertEqual(schedule, expected_schedule)
def test_build_polynomial_scheduler(self):
config = self._get_valid_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, PolynomialDecayParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_polynomial_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.losses import (
build_loss,
ClassyLoss,
MultiOutputSumLoss,
register_loss,
)
@register_loss("mock_1")
class MockLoss1(ClassyLoss):
def forward(self, pred, target):
return torch.tensor(1.0)
@classmethod
def from_config(cls, config):
return cls()
class TestMultiOutputSumLoss(unittest.TestCase):
def test_multi_output_sum_loss(self):
config = {"name": "multi_output_sum_loss", "loss": {"name": "mock_1"}}
crit = build_loss(config)
self.assertTrue(isinstance(crit, MultiOutputSumLoss))
# test with a single output
output = torch.tensor([1.0, 2.3])
target = torch.tensor(1.0)
self.assertAlmostEqual(crit(output, target).item(), 1.0)
# test with a list of outputs
output = [torch.tensor([1.2, 3.2])] * 5
target = torch.tensor(2.3)
self.assertAlmostEqual(crit(output, target).item(), 5.0)
|
ClassyVision-main
|
test/losses_multi_output_sum_loss_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from typing import Any, Dict
from unittest import mock
import torch
import torch.nn as nn
from classy_vision.generic.util import get_checkpoint_dict
from classy_vision.losses import ClassyLoss, register_loss
from classy_vision.tasks import build_task, FineTuningTask
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_fast_test_task_config
from test.generic.utils import compare_model_state
from torch.nn.modules.loss import CrossEntropyLoss
@register_loss("batchnorm_cross_entropy_loss")
class BatchNormCrossEntropyLoss(ClassyLoss):
"""A special loss containing a BatchNorm module"""
def __init__(self, num_classes):
super().__init__()
self.bn = nn.BatchNorm1d(num_classes)
self.fc = nn.Linear(num_classes, num_classes)
self.xent = CrossEntropyLoss()
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "BatchNormCrossEntropyLoss":
assert "num_classes" in config
return cls(config["num_classes"])
def forward(self, x, target):
return self.xent(self.fc(self.bn(x)), target)
class TestFineTuningTask(unittest.TestCase):
def _compare_model_state(self, state_1, state_2, check_heads=True):
return compare_model_state(self, state_1, state_2, check_heads=check_heads)
def _compare_state_dict(self, state_1, state_2, check_heads=True):
for k in state_1.keys():
self.assertTrue(torch.allclose(state_1[k].cpu(), state_2[k].cpu()))
def _get_fine_tuning_config(
self, head_num_classes=100, pretrained_checkpoint=False
):
config = get_fast_test_task_config(head_num_classes=head_num_classes)
config["name"] = "fine_tuning"
config["num_epochs"] = 2
if pretrained_checkpoint:
config["pretrained_checkpoint"] = "/path/to/pretrained/checkpoint"
return config
def _get_pre_train_config(self, head_num_classes=100):
config = get_fast_test_task_config(head_num_classes=head_num_classes)
config["num_epochs"] = 2
return config
def test_build_task(self):
config = self._get_fine_tuning_config()
task = build_task(config)
self.assertIsInstance(task, FineTuningTask)
config = self._get_fine_tuning_config(pretrained_checkpoint=True)
with mock.patch("classy_vision.tasks.FineTuningTask.set_pretrained_checkpoint"):
task = build_task(config)
self.assertIsInstance(task, FineTuningTask)
def test_prepare(self):
pre_train_config = self._get_pre_train_config()
pre_train_task = build_task(pre_train_config)
pre_train_task.prepare()
checkpoint = get_checkpoint_dict(pre_train_task, {})
fine_tuning_config = self._get_fine_tuning_config()
fine_tuning_task = build_task(fine_tuning_config)
# test: cannot prepare a fine tuning task without a pre-trained checkpoint
with self.assertRaises(Exception):
fine_tuning_task.prepare()
# test: prepare should succeed after pre-trained checkpoint is set
fine_tuning_task = build_task(fine_tuning_config)
fine_tuning_task._set_pretrained_checkpoint_dict(checkpoint)
fine_tuning_task.prepare()
# test: prepare should succeed if a pre-trained checkpoint is provided in the
# config
fine_tuning_config = self._get_fine_tuning_config(pretrained_checkpoint=True)
fine_tuning_task = build_task(fine_tuning_config)
with mock.patch(
"classy_vision.tasks.fine_tuning_task.load_and_broadcast_checkpoint",
return_value=checkpoint,
):
fine_tuning_task.prepare()
# test: a fine tuning task with incompatible heads with a manually set
# pre-trained checkpoint should fail to prepare if the heads are not reset
fine_tuning_config = self._get_fine_tuning_config(head_num_classes=10)
fine_tuning_task = build_task(fine_tuning_config)
fine_tuning_task._set_pretrained_checkpoint_dict(checkpoint)
with self.assertRaises(Exception):
fine_tuning_task.prepare()
# test: a fine tuning task with incompatible heads with a manually set
# pre-trained checkpoint should succeed to prepare if the heads are reset
fine_tuning_task = build_task(fine_tuning_config)
fine_tuning_task._set_pretrained_checkpoint_dict(
copy.deepcopy(checkpoint)
).set_reset_heads(True)
fine_tuning_task.prepare()
# test: a fine tuning task with incompatible heads with the pre-trained
# checkpoint provided in the config should fail to prepare
fine_tuning_config = self._get_fine_tuning_config(
head_num_classes=10, pretrained_checkpoint=True
)
fine_tuning_task = build_task(fine_tuning_config)
with mock.patch(
"classy_vision.tasks.fine_tuning_task.load_and_broadcast_checkpoint",
return_value=copy.deepcopy(checkpoint),
) and self.assertRaises(Exception):
fine_tuning_task.prepare()
# test: a fine tuning task with incompatible heads with the pre-trained
# checkpoint provided in the config should succeed to prepare if the heads are
# reset
fine_tuning_task = build_task(fine_tuning_config)
fine_tuning_task.set_reset_heads(True)
with mock.patch(
"classy_vision.tasks.fine_tuning_task.load_and_broadcast_checkpoint",
return_value=copy.deepcopy(checkpoint),
):
fine_tuning_task.prepare()
def test_train(self):
pre_train_config = self._get_pre_train_config(head_num_classes=100)
pre_train_task = build_task(pre_train_config)
trainer = LocalTrainer()
trainer.train(pre_train_task)
checkpoint = get_checkpoint_dict(pre_train_task, {})
for reset_heads, heads_num_classes in [(False, 100), (True, 20)]:
for freeze_trunk in [True, False]:
fine_tuning_config = self._get_fine_tuning_config(
head_num_classes=heads_num_classes
)
fine_tuning_task = build_task(fine_tuning_config)
fine_tuning_task = (
fine_tuning_task._set_pretrained_checkpoint_dict(
copy.deepcopy(checkpoint)
)
.set_reset_heads(reset_heads)
.set_freeze_trunk(freeze_trunk)
)
# run in test mode to compare the model state
fine_tuning_task.set_test_only(True)
trainer.train(fine_tuning_task)
self._compare_model_state(
pre_train_task.model.get_classy_state(),
fine_tuning_task.model.get_classy_state(),
check_heads=not reset_heads,
)
# run in train mode to check accuracy
fine_tuning_task.set_test_only(False)
trainer.train(fine_tuning_task)
if freeze_trunk:
# if trunk is frozen the states should be the same
self._compare_model_state(
pre_train_task.model.get_classy_state(),
fine_tuning_task.model.get_classy_state(),
check_heads=False,
)
else:
# trunk isn't frozen, the states should be different
with self.assertRaises(Exception):
self._compare_model_state(
pre_train_task.model.get_classy_state(),
fine_tuning_task.model.get_classy_state(),
check_heads=False,
)
accuracy = fine_tuning_task.meters[0].value["top_1"]
self.assertAlmostEqual(accuracy, 1.0)
def test_train_parametric_loss(self):
heads_num_classes = 100
pre_train_config = self._get_pre_train_config(
head_num_classes=heads_num_classes
)
pre_train_config["loss"] = {
"name": "batchnorm_cross_entropy_loss",
"num_classes": heads_num_classes,
}
pre_train_task = build_task(pre_train_config)
trainer = LocalTrainer()
trainer.train(pre_train_task)
checkpoint = get_checkpoint_dict(pre_train_task, {})
fine_tuning_config = self._get_fine_tuning_config(
head_num_classes=heads_num_classes
)
fine_tuning_config["loss"] = {
"name": "batchnorm_cross_entropy_loss",
"num_classes": heads_num_classes,
}
fine_tuning_task = build_task(fine_tuning_config)
fine_tuning_task._set_pretrained_checkpoint_dict(copy.deepcopy(checkpoint))
# run in test mode to compare the loss state. Since we have a BatchNorm module in
# the loss, its moving mean/std should be unchanged when we run in test-only mode
fine_tuning_task.set_test_only(True)
loss_state = copy.deepcopy(fine_tuning_task.loss.get_classy_state())
trainer.train(fine_tuning_task)
self._compare_state_dict(loss_state, fine_tuning_task.loss.get_classy_state())
|
ClassyVision-main
|
test/tasks_fine_tuning_task_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
|
ClassyVision-main
|
test/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
import torch.nn as nn
from classy_vision.generic.profiler import (
compute_activations,
compute_flops,
count_params,
get_shape,
)
from classy_vision.models import build_model
from test.generic.config_utils import get_test_model_configs
class TestModule(nn.Module):
def __init__(self):
super().__init__()
# add parameters to the module to affect the parameter count
self.linear = nn.Linear(2, 3, bias=False)
def forward(self, x):
return x + 1
def flops(self, x):
# TODO: this should raise an exception if this function is not defined
# since the FLOPs are indeterminable
# need to define flops since this is an unknown class
return x.numel()
class TestConvModule(nn.Conv2d):
def __init__(self):
super().__init__(2, 3, (4, 4), bias=False)
# add another (unused) layer for added complexity and to test parameters
self.linear = nn.Linear(4, 5, bias=False)
def forward(self, x):
return x
def activations(self, x, out):
# TODO: this should ideally work without this function being defined
return out.numel()
def flops(self, x):
# need to define flops since this is an unknown class
return 0
class TestModuleWithTwoArguments(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x1, x2):
return x1 + x2
def flops(self, x1, x2):
return x1.numel()
class TestModuleDoubleValue(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(10, 10, bias=False)
self.add = TestModuleWithTwoArguments()
def forward(self, x):
x = self.linear(x)
return self.add(x, x)
class TestModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(300, 300, bias=False)
self.mod = TestModule()
self.conv = TestConvModule()
# we should be able to pick up user defined parameters as well
self.extra_params = nn.Parameter(torch.randn(10, 10))
# we shouldn't count flops for an unused layer
self.unused_linear = nn.Linear(2, 2, bias=False)
def forward(self, x):
out = self.conv(x)
out = out.view(out.shape[0], -1)
out = self.mod(out)
return self.linear(out)
class TestModel2(nn.Module):
def __init__(self):
super().__init__()
# create a model which re-uses a module (conv_module in this case)
conv_module = nn.Conv2d(3, 3, (2, 2), bias=False)
self.seq_1 = nn.Sequential(conv_module)
self.seq_2 = nn.Sequential(conv_module)
def forward(self, x):
return self.seq_1(x) + self.seq_2(x)
class TestModuleWithoutFlops(nn.Module):
# this module doesn't have FLOPs defined
def forward(self, x):
return x
class TestModuleWithFlops(nn.Module):
# this module does have FLOPs defined
_flops = 1234
def __init__(self):
super().__init__()
self.mod = TestModuleWithoutFlops()
# add a conv module; this shouldn't impact the FLOPs since we define
# self.flops()
self.conv = nn.Conv2d(3, 3, (2, 2))
def forward(self, x):
return self.conv(x)
def flops(self, x):
return self._flops
class TestProfilerFunctions(unittest.TestCase):
def test_complexity_calculation_resnext(self) -> None:
model_configs = get_test_model_configs()
# make sure there are three configs returned
self.assertEqual(len(model_configs), 3)
# expected values which allow minor deviations from model changes
# we only test at the 10^6 scale
expected_m_flops = [4122, 7850, 8034]
expected_m_params = [25, 44, 44]
expected_m_activations = [11, 16, 21]
for model_config, m_flops, m_params, m_activations in zip(
model_configs, expected_m_flops, expected_m_params, expected_m_activations
):
model = build_model(model_config)
self.assertEqual(compute_activations(model) // 10**6, m_activations)
self.assertEqual(compute_flops(model) // 10**6, m_flops)
self.assertEqual(count_params(model) // 10**6, m_params)
def test_complexity_calculation(self) -> None:
model = TestModel()
input_shape = (3, 10, 10)
num_elems = 3 * 10 * 10
activations = num_elems + num_elems # linear + conv
self.assertEqual(
compute_activations(model, input_shape=input_shape), activations
)
self.assertEqual(
compute_flops(model, input_shape=input_shape),
num_elems
+ 0
+ (300 * 300), # TestModule + TestConvModule + TestModel.linear;
# TestModel.unused_linear is unused and shouldn't be counted
)
self.assertEqual(
count_params(model),
(2 * 3) + (2 * 3 * 4 * 4) + (4 * 5) + (300 * 300) + (10 * 10) + (2 * 2),
) # TestModule.linear + TestConvModule + TestConvModule.linear +
# TestModel.linear + TestModel.extra_params + TestModel.unused_linear
# test that we calculate complexity correctly for a model which re-uses a module
model = TestModel2()
in_channels = 3
out_channels = 3
out_h, out_w = 9, 9
kernel_h, kernel_w = 2, 2
conv_flops = in_channels * out_channels * out_h * out_w * kernel_h * kernel_w
conv_activations = out_channels * out_h * out_w
self.assertEqual(
compute_activations(model, input_shape=input_shape), conv_activations * 2
) # the conv is applied twice
self.assertEqual(
compute_flops(model, input_shape=input_shape), conv_flops * 2
) # the conv is applied twice
self.assertEqual(
count_params(model), in_channels * out_channels * kernel_h * kernel_w
)
def test_flops_calculation(self):
# test that a model containing a custom module which doesn't have FLOPs defined
# raises an exception
model = nn.Sequential(TestModuleWithoutFlops())
input_shape = (3, 10, 10)
with self.assertRaises(Exception):
compute_flops(model, input_shape=input_shape)
# test that a model containing a custom module does have FLOPs defined works,
# even if the module has children which don't define FLOPs
model = nn.Sequential(TestModuleWithFlops())
input_shape = (3, 10, 10)
self.assertEqual(
compute_flops(model, input_shape=input_shape), TestModuleWithFlops._flops
) # the conv is applied twice
# test that a model has a module which takes two positional arguments
model = nn.Sequential(TestModuleDoubleValue())
input_shape = (10,)
self.assertEqual(compute_flops(model, input_shape=input_shape), 110)
class TestHelperFunctions(unittest.TestCase):
def test_get_shape(self) -> None:
list_x = [torch.zeros(2, 4), torch.zeros(3, 3)]
shapes = get_shape(list_x)
expected_shapes = [torch.zeros(2, 4).size(), torch.zeros(3, 3).size()]
for shape, expected in zip(shapes, expected_shapes):
self.assertEqual(shape, expected)
dict_x = {"x1": torch.zeros(2, 4), "x2": torch.zeros(3, 3)}
shapes = get_shape(dict_x)
expected_shapes = {
"x1": torch.zeros(2, 4).size(),
"x2": torch.zeros(3, 3).size(),
}
for k, shape in shapes.items():
self.assertEqual(shape, expected_shapes[k])
list_dict_x = [
{"x1": torch.zeros(2, 4), "x2": torch.zeros(3, 3)},
{"x1": torch.zeros(3, 4), "x2": torch.zeros(4, 5)},
]
shapes = get_shape(list_dict_x)
expected_shapes = [
{"x1": torch.zeros(2, 4).size(), "x2": torch.zeros(3, 3).size()},
{"x1": torch.zeros(3, 4).size(), "x2": torch.zeros(4, 5).size()},
]
for shape, expected in zip(shapes, expected_shapes):
for k, s in shape.items():
self.assertEqual(s, expected[k])
|
ClassyVision-main
|
test/generic_profiler_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
LinearParamScheduler,
)
class TestLienarScheduler(unittest.TestCase):
_num_epochs = 10
def _get_valid_intermediate(self):
return [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]
def _get_valid_config(self):
return {"name": "linear", "start_value": 0.0, "end_value": 0.1}
def test_invalid_config(self):
config = self._get_valid_config()
bad_config = copy.deepcopy(config)
# No start lr
del bad_config["start_value"]
with self.assertRaises((AssertionError, TypeError)):
LinearParamScheduler.from_config(bad_config)
# No end lr
bad_config["start_value"] = config["start_value"]
del bad_config["end_value"]
with self.assertRaises((AssertionError, TypeError)):
LinearParamScheduler.from_config(bad_config)
def test_scheduler(self):
config = self._get_valid_config()
# Check as warmup
scheduler = LinearParamScheduler.from_config(config)
schedule = [
round(scheduler(epoch_num / self._num_epochs), 4)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [config["start_value"]] + self._get_valid_intermediate()
self.assertEqual(schedule, expected_schedule)
# Check as decay
tmp = config["start_value"]
config["start_value"] = config["end_value"]
config["end_value"] = tmp
scheduler = LinearParamScheduler.from_config(config)
schedule = [
round(scheduler(epoch_num / self._num_epochs), 4)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [config["start_value"]] + list(
reversed(self._get_valid_intermediate())
)
self.assertEqual(schedule, expected_schedule)
def test_build_linear_scheduler(self):
config = self._get_valid_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, LinearParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_linear_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.heads.vision_transformer_head import VisionTransformerHead
class TestVisionTransformerHead(unittest.TestCase):
def test_vision_transformer_head(self):
batch_size = 2
in_plane = 3
num_classes = 5
head = VisionTransformerHead(
"default_head",
num_classes=num_classes,
in_plane=in_plane,
)
input = torch.rand([batch_size, in_plane])
output = head(input)
self.assertEqual(output.shape, torch.Size([batch_size, num_classes]))
def test_vision_transformer_head_normalize_inputs(self):
batch_size = 2
in_plane = 3
head = VisionTransformerHead(
"default_head",
num_classes=None,
in_plane=in_plane,
normalize_inputs="l2",
)
input = torch.rand([batch_size, in_plane])
output = head(input)
self.assertEqual(output.shape, torch.Size([batch_size, in_plane]))
for i in range(batch_size):
output_i = output[i]
self.assertAlmostEqual(output_i.norm().item(), 1, places=3)
|
ClassyVision-main
|
test/heads_vision_transformer_head_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import multiprocessing as mp
import unittest
import unittest.mock as mock
import classy_vision.dataset.classy_dataset as classy_dataset
import torch
from classy_vision.dataset import build_dataset, register_dataset
from classy_vision.dataset.core import ListDataset
from test.generic.utils import compare_batches, compare_samples
from torch.utils.data import DataLoader
DUMMY_SAMPLES_1 = [
{"input": torch.tensor([[[0, 1], [2, 3]]]), "target": torch.tensor([[0]])}
]
DUMMY_SAMPLES_2 = [
{"input": torch.tensor([[[0, 1], [2, 3]]]), "target": torch.tensor([[0]])},
{"input": torch.tensor([[[4, 5], [6, 7]]]), "target": torch.tensor([[1]])},
]
BATCHED_DUMMY_SAMPLES_2 = [
{
"input": torch.tensor([[[[0, 1], [2, 3]]], [[[4, 5], [6, 7]]]]),
"target": torch.tensor([[[0]], [[1]]]),
}
]
DUMMY_CONFIG = {"name": "test_dataset", "dummy0": 0, "dummy1": 1}
OTHER_DUMMY_CONFIG = {"name": "other_test_dataset", "dummy0": 0, "dummy1": 1}
def mock_get_world_size():
return 2
def mock_get_rank():
return 1
@register_dataset("test_dataset")
class TestDataset(classy_dataset.ClassyDataset):
"""Test dataset for validating registry functions"""
def __init__(
self,
samples,
batchsize_per_replica=1,
num_samples=None,
shuffle=False,
transform=None,
):
input_tensors = [sample["input"] for sample in samples]
target_tensors = [sample["target"] for sample in samples]
dataset = ListDataset(input_tensors, target_tensors, loader=lambda x: x)
super().__init__(
dataset=dataset,
batchsize_per_replica=batchsize_per_replica,
shuffle=shuffle,
transform=transform,
num_samples=len(samples) if num_samples is None else num_samples,
)
@classmethod
def from_config(cls, config, *args, **kwargs):
return cls(*args, **kwargs)
@register_dataset("other_test_dataset")
class OtherTestDataset(classy_dataset.ClassyDataset):
"""
Test dataset for validating registry functions that has a different
type than TestDataset
"""
def __init__(self, samples, batchsize_per_replica=1):
input_tensors = [sample["input"] for sample in samples]
target_tensors = [sample["target"] for sample in samples]
dataset = ListDataset(input_tensors, target_tensors, loader=lambda x: x)
super().__init__(
dataset=dataset,
batchsize_per_replica=batchsize_per_replica,
shuffle=False,
transform=None,
num_samples=len(samples),
)
@classmethod
def from_config(cls, config, *args, **kwargs):
return cls(*args, **kwargs)
class TestRegistryFunctions(unittest.TestCase):
"""
Tests functions that use registry
"""
def test_build_model(self):
dataset = build_dataset(DUMMY_CONFIG, DUMMY_SAMPLES_1)
self.assertTrue(isinstance(dataset, TestDataset))
class TestClassyDataset(unittest.TestCase):
"""
Tests member functions of ClassyDataset. Note, NotImplemented
functions are mocked in TestDataset class.
"""
def setUp(self):
self.dataset1 = build_dataset(DUMMY_CONFIG, DUMMY_SAMPLES_1)
self.dataset2 = build_dataset(DUMMY_CONFIG, DUMMY_SAMPLES_2)
def _compare_samples(self, sample1, sample2):
compare_samples(self, sample1, sample2)
def _compare_batches(self, batch1, batch2):
compare_batches(self, batch1, batch2)
def test_init(self):
self.assertTrue(self.dataset1 is not None)
self.assertTrue(self.dataset2 is not None)
def test_len(self):
self.assertEqual(len(self.dataset1), 1)
self.assertEqual(len(self.dataset2), 2)
def test_getitem(self):
sample = self.dataset1[0]
self._compare_samples(sample, DUMMY_SAMPLES_1[0])
for idx in range(len(self.dataset2)):
sample = self.dataset2[idx]
self._compare_samples(sample, DUMMY_SAMPLES_2[idx])
def test_get_iterator(self):
# Verifies that we can retrieve samples with iterators
dl = self.dataset1.iterator(num_workers=0)
assert isinstance(
dl, DataLoader
), "Classy Iterator should return instance of PyTorch Dataloader"
next(iter(dl))
# We should be able to set num_workers to zero while also passing a mp context
dl = self.dataset1.iterator(
num_workers=0, multiprocessing_context=mp.get_context()
)
assert isinstance(
dl, DataLoader
), "Classy Iterator should return instance of PyTorch Dataloader"
next(iter(dl))
dl = self.dataset1.iterator(num_workers=2)
assert isinstance(
dl, DataLoader
), "Classy Iterator should return instance of PyTorch Dataloader"
it = iter(dl)
next(it)
# Because we use multiprocessing we delete the iterable to
# shutdown workers
del it
def test_batch_logic(self):
dataset = TestDataset(DUMMY_SAMPLES_2, batchsize_per_replica=2)
dl = dataset.iterator(num_workers=0)
batch = next(iter(dl))
self.assertEqual(batch["input"].size()[0], 2)
self._compare_batches(batch, BATCHED_DUMMY_SAMPLES_2[0])
@mock.patch(
"classy_vision.dataset.classy_dataset.get_world_size", mock_get_world_size
)
@mock.patch("classy_vision.dataset.classy_dataset.get_rank", mock_get_rank)
def test_shard_logic(self):
# This test uses a world size of 2, rank 1 to verify that the
# second sample is returned by the dataloader
dataset = TestDataset(DUMMY_SAMPLES_2, batchsize_per_replica=1)
dl = dataset.iterator(num_workers=0)
sample = next(iter(dl))
self._compare_batches(sample, DUMMY_SAMPLES_2[1])
def test_num_samples_logic(self):
dataset = TestDataset(DUMMY_SAMPLES_2)
self.assertEqual(len(dataset), 2)
dataset = TestDataset(DUMMY_SAMPLES_2, num_samples=1)
# Verify len returns right value for dataset
self.assertEqual(len(dataset), 1)
# Verify len returns right value for iterator
self.assertEqual(len(dataset.iterator(num_workers=0)), 1)
# Verify iterator returns correct number of samples
it = iter(dataset.iterator(num_workers=0))
num_samples = 0
while True:
try:
next(it)
num_samples += 1
except StopIteration:
break
self.assertEqual(num_samples, 1)
# Check assert for num_samples > length of base dataset
dataset = TestDataset(DUMMY_SAMPLES_2, num_samples=3)
with self.assertRaises(AssertionError):
len(dataset)
def test_shuffle_logic(self):
# Simple samples to test shuffling, just a single value tensor
# so we know how things were shuffled
dummy_samples_10 = [
{"input": torch.tensor([[0]]), "target": torch.tensor([0])},
{"input": torch.tensor([[1]]), "target": torch.tensor([0])},
{"input": torch.tensor([[2]]), "target": torch.tensor([0])},
{"input": torch.tensor([[3]]), "target": torch.tensor([0])},
{"input": torch.tensor([[4]]), "target": torch.tensor([0])},
{"input": torch.tensor([[5]]), "target": torch.tensor([0])},
{"input": torch.tensor([[6]]), "target": torch.tensor([0])},
{"input": torch.tensor([[7]]), "target": torch.tensor([0])},
{"input": torch.tensor([[8]]), "target": torch.tensor([0])},
{"input": torch.tensor([[9]]), "target": torch.tensor([0])},
]
dataset = TestDataset(dummy_samples_10, shuffle=True)
def unpack_tensors(tensor_list):
return [t["input"].item() for t in tensor_list]
# Epoch 0
iterator = dataset.iterator(num_workers=0, current_phase_id=0)
it = iter(iterator)
epoch_0_list = [sample for sample in it]
epoch_0_list = unpack_tensors(epoch_0_list)
# Epoch 1
iterator = dataset.iterator(num_workers=0, current_phase_id=1)
it = iter(iterator)
epoch_1_list = [sample for sample in it]
epoch_1_list = unpack_tensors(epoch_1_list)
# Should be same length, should be shuffled, should be
# different shuffles for each epoch
self.assertEqual(len(epoch_0_list), len(epoch_1_list))
self.assertTrue(epoch_0_list != [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertTrue(epoch_0_list != epoch_1_list)
# Test different shuffle seeds
iterator = dataset.iterator(num_workers=0, current_phase_id=0, shuffle_seed=10)
it = iter(iterator)
epoch_0_seed_10_list = [sample for sample in it]
epoch_0_seed_10_list = unpack_tensors(epoch_0_seed_10_list)
self.assertTrue(epoch_0_seed_10_list != epoch_0_list)
def test_transform_logic(self):
def _return_1_transform(sample):
return 1
dataset = TestDataset(DUMMY_SAMPLES_2, transform=_return_1_transform)
sample = dataset[0]
self.assertEqual(sample, 1)
|
ClassyVision-main
|
test/dataset_classy_dataset_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.generic.util import get_torch_version
from classy_vision.models import build_model
from test.generic.utils import compare_model_state
MODELS = {
"small_densenet": {
"name": "densenet",
"num_blocks": [1, 1, 1, 1],
"init_planes": 4,
"growth_rate": 32,
"expansion": 4,
"final_bn_relu": True,
"small_input": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "trunk_output",
"in_plane": 60,
"zero_init_bias": True,
}
],
},
"small_densenet_se": {
"name": "densenet",
"num_blocks": [1, 1, 1, 1],
"init_planes": 4,
"growth_rate": 32,
"expansion": 4,
"final_bn_relu": True,
"small_input": True,
"use_se": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "trunk_output",
"in_plane": 60,
"zero_init_bias": True,
}
],
},
}
def _find_block_full_path(model, block_name):
"""Find the full path for a given block name
e.g. block3-1 --> 3.block3-1
"""
for name, _ in model.named_modules():
if name.endswith(block_name):
return name
return None
class TestDensenet(unittest.TestCase):
def _test_model(self, model_config):
"""This test will build Densenet models, run a forward pass and
verify output shape, and then verify that get / set state
works.
I do this in one test so that we construct the model a minimum
number of times.
"""
model = build_model(model_config)
# Verify forward pass works
input = torch.ones([1, 3, 32, 32])
output = model.forward(input)
self.assertEqual(output.size(), (1, 1000))
# Verify get_set_state
new_model = build_model(model_config)
state = model.get_classy_state()
new_model.set_classy_state(state)
new_state = new_model.get_classy_state()
compare_model_state(self, state, new_state, check_heads=True)
def _test_quantize_model(self, model_config):
if get_torch_version() >= [1, 11]:
import torch.ao.quantization as tq
from torch.ao.quantization.quantize_fx import convert_fx, prepare_fx
else:
import torch.quantization as tq
from torch.quantization.quantize_fx import convert_fx, prepare_fx
# quantize model
model = build_model(model_config)
model.eval()
input = torch.ones([1, 3, 32, 32])
heads = model.get_heads()
# since prepare changes the code of ClassyBlock we need to clear head first
# and reattach it later to avoid caching
model.clear_heads()
prepare_custom_config_dict = {}
head_path_from_blocks = [
_find_block_full_path(model.features, block_name)
for block_name in heads.keys()
]
fqn_to_example_inputs = None
if get_torch_version() >= [1, 13]:
from torch.ao.quantization.utils import get_fqn_to_example_inputs
fqn_to_example_inputs = get_fqn_to_example_inputs(model, (input,))
standalone_example_inputs = (torch.randn(1, 3, 3, 3),)
# we need to keep the modules used in head standalone since
# it will be accessed with path name directly in execution
if get_torch_version() >= [1, 13]:
prepare_custom_config_dict["standalone_module_name"] = [
(
head,
{"": tq.default_qconfig},
fqn_to_example_inputs["features." + head],
{"input_quantized_idxs": [0], "output_quantized_idxs": []},
None,
)
for head in head_path_from_blocks
]
else:
prepare_custom_config_dict["standalone_module_name"] = [
(
head,
{"": tq.default_qconfig},
standalone_example_inputs,
{"input_quantized_idxs": [0], "output_quantized_idxs": []},
None,
)
for head in head_path_from_blocks
]
example_inputs = (torch.randn(1, 3, 3, 3),)
if get_torch_version() >= [1, 13]:
example_inputs = fqn_to_example_inputs["initial_block"]
model.initial_block = prepare_fx(
model.initial_block, {"": tq.default_qconfig}, example_inputs
)
if get_torch_version() >= [1, 13]:
example_inputs = fqn_to_example_inputs["features"]
model.features = prepare_fx(
model.features,
{"": tq.default_qconfig},
example_inputs,
prepare_custom_config_dict,
)
model.set_heads(heads)
# calibration
model(input)
heads = model.get_heads()
model.clear_heads()
model.initial_block = convert_fx(model.initial_block)
model.features = convert_fx(model.features)
model.set_heads(heads)
output = model(input)
self.assertEqual(output.size(), (1, 1000))
def test_small_densenet(self):
self._test_model(MODELS["small_densenet"])
@unittest.skipIf(
get_torch_version() < [1, 13],
"This test is using a new api of FX Graph Mode Quantization which is only available after 1.13",
)
def test_quantized_small_densenet(self):
self._test_quantize_model(MODELS["small_densenet"])
|
ClassyVision-main
|
test/models_densenet_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import classy_vision.heads.fully_convolutional_linear_head as fcl
import torch
class TestFullyConvolutionalLinearHead(unittest.TestCase):
def test_fully_convolutional_linear_head(self):
head = fcl.FullyConvolutionalLinearHead(
"default_head",
num_classes=2,
in_plane=3,
pool_size=[1, 3, 3],
activation_func="softmax",
use_dropout=False,
)
input = torch.rand([1, 3, 4, 3, 3])
output = head(input)
self.assertEqual(output.shape, torch.Size([1, 8]))
def test_fully_convolutional_linear_head_eval(self):
head = fcl.FullyConvolutionalLinearHead(
"default_head",
num_classes=2,
in_plane=3,
pool_size=[1, 3, 3],
activation_func="softmax",
use_dropout=False,
).eval()
input = torch.rand([1, 3, 4, 3, 3])
output = head(input)
self.assertEqual(output.shape, torch.Size([1, 2]))
def test_fully_convolutional_linear_head_from_cfg(self):
head_cfg = {
"name": "fully_convolutional_linear",
"unique_id": "default_head",
"activation_func": "softmax",
"pool_size": [1, 3, 3],
"num_classes": 2,
"in_plane": 3,
"use_dropout": False,
}
head = fcl.FullyConvolutionalLinearHead.from_config(head_cfg)
input = torch.rand([1, 3, 4, 3, 3])
output = head(input)
self.assertEqual(output.shape, torch.Size([1, 8]))
def test_fully_convolutional_linear_head_adaptive_pool(self):
head = fcl.FullyConvolutionalLinearHead(
"default_head",
num_classes=2,
in_plane=3,
pool_size=None,
activation_func="softmax",
use_dropout=False,
)
input = torch.rand([1, 3, 4, 3, 3])
output = head(input)
self.assertEqual(output.shape, torch.Size([1, 2]))
def test_fully_convolutional_linear_head_adaptive_pool_from_cfg(self):
head_cfg = {
"name": "fully_convolutional_linear",
"unique_id": "default_head",
"activation_func": "softmax",
"num_classes": 2,
"in_plane": 3,
"use_dropout": False,
}
head = fcl.FullyConvolutionalLinearHead.from_config(head_cfg)
input = torch.rand([1, 3, 4, 3, 3])
output = head(input)
self.assertEqual(output.shape, torch.Size([1, 2]))
|
ClassyVision-main
|
test/heads_fully_convolutional_linear_head_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.optim.rmsprop import RMSProp
from test.generic.optim_test_util import TestOptimizer
class TestRMSPropOptimizer(TestOptimizer, unittest.TestCase):
def _get_config(self):
return {
"name": "rmsprop",
"num_epochs": 90,
"lr": 0.1,
"momentum": 0.9,
"weight_decay": 0.0001,
"alpha": 0.9,
"eps": 1e-8,
"centered": False,
}
def _instance_to_test(self):
return RMSProp
|
ClassyVision-main
|
test/optim_rmsprop_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
import torch.nn as nn
from classy_vision.heads import ClassyHead
from classy_vision.models import (
ClassyModel,
ClassyModelHeadExecutorWrapper,
ClassyModelWrapper,
)
class TestClassyBlock(unittest.TestCase):
def setUp(self):
self.orig_wrapper_cls = self.DummyTestModel.wrapper_cls
def tearDown(self):
self.DummyTestModel.wrapper_cls = self.orig_wrapper_cls
class DummyTestHead(ClassyHead):
def __init__(self):
super().__init__("head_id")
self.layer = torch.nn.Linear(2, 2)
def forward(self, x):
return self.layer(x)
class DummyTestModel(ClassyModel):
def __init__(self):
super().__init__()
self.dummy_block = torch.nn.Linear(2, 2)
self.dummy_block2 = torch.nn.Linear(2, 2)
def forward(self, x):
out = self.dummy_block(x)
return self.dummy_block2(out)
class DummyTestModelDuplicatedBlockNames(ClassyModel):
def __init__(self):
super().__init__()
self.dummy_block = torch.nn.Linear(2, 2)
self.features = nn.Sequential()
self.features.add_module("dummy_model", torch.nn.Linear(2, 2))
def forward(self, x):
out = self.dummy_block(x)
return self.features.dummy_block(out)
def test_head_execution(self):
# test head outputs without any extra wrapper logic, which is the case with
# no wrappers or the base ClassyModelWrapper class
for wrapper_class in [None, ClassyModelWrapper]:
self.DummyTestModel.wrapper_cls = wrapper_class
model = self.DummyTestModel()
head = self.DummyTestHead()
model.set_heads({"dummy_block2": [head]})
input = torch.randn(1, 2)
output = model(input)
head_output = model.execute_heads()
self.assertTrue(torch.allclose(head(output), head_output["head_id"]))
# test that the head output is returned automatically with the
# ClassyModelHeadExecutorWrapper
self.DummyTestModel.wrapper_cls = ClassyModelHeadExecutorWrapper
model = self.DummyTestModel()
head = self.DummyTestHead()
model.set_heads({"dummy_block2": [head]})
input = torch.randn(1, 2)
output = model(input)
head_output = model.execute_heads()
self.assertTrue(torch.allclose(output, head_output["head_id"]))
def test_duplicated_head_ids(self):
model = self.DummyTestModel()
head1 = self.DummyTestHead()
head2 = self.DummyTestHead()
heads = {"dummy_block": [head1], "dummy_block2": [head2]}
with self.assertRaises(ValueError):
model.set_heads(heads)
head2.unique_id = "head_id2"
model.set_heads(heads)
def test_duplicated_block_names(self):
model = self.DummyTestModelDuplicatedBlockNames()
head = self.DummyTestHead()
heads = {"dummy_block2": [head]}
with self.assertRaises(Exception):
# there are two modules with the name "dummy_block2"
# which is not supported
model.set_heads(heads)
# can still attach to a module with a unique id
heads = {"features": [head]}
model.set_heads(heads)
def test_set_heads(self):
model = self.DummyTestModel()
head = self.DummyTestHead()
self.assertEqual(
len(model.get_heads()), 0, "heads should be empty before set_heads"
)
model.set_heads({"dummy_block2": [head]})
input = torch.randn(1, 2)
model(input)
head_outputs = model.execute_heads()
self.assertEqual(len(head_outputs), 1, "should have output for one head")
# remove all heads
model.set_heads({})
self.assertEqual(len(model.get_heads()), 0, "heads should be empty")
# try a non-existing module
with self.assertRaises(Exception):
model.set_heads({"unknown_block": [head]})
|
ClassyVision-main
|
test/models_classy_block_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import numpy as np
import torch
import torchvision.transforms as transforms
from classy_vision.dataset.dataloader_async_gpu_wrapper import DataloaderAsyncGPUWrapper
from PIL import Image
from torch.utils.data import DataLoader, Dataset
class ZeroImageDataset(Dataset):
def __init__(self, crop_size, num_channels, num_classes, num_samples):
self.crop_size = crop_size
self.num_channels = num_channels
self.num_classes = num_classes
self.num_samples = num_samples
def __iter__(self):
# Spread work as mod(N)
worker_info = torch.utils.data.get_worker_info()
if worker_info is None:
return iter(range(self.num_samples))
else:
return iter(
range(worker_info.id, self.num_samples, worker_info.num_workers)
)
def __getitem__(self, index):
input_data = transforms.ToTensor()(
Image.fromarray(
np.zeros(
(self.crop_size, self.crop_size, self.num_channels), dtype=np.uint8
)
)
)
target = np.random.randint(self.num_classes)
return {"input": input_data, "target": target, "id": index}
def __len__(self):
return self.num_samples
class TestDataloaderAsyncGPUWrapper(unittest.TestCase):
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_dataset_async(self):
"""
Test that streaming datasets return the correct number of batches, and that
the length is also calculated correctly.
"""
NUM_SAMPLES = 1024
dataset = ZeroImageDataset(
crop_size=224, num_channels=3, num_classes=1000, num_samples=NUM_SAMPLES
)
base_dataloader = DataLoader(dataset=dataset, pin_memory=True, num_workers=20)
dataloader = DataloaderAsyncGPUWrapper(base_dataloader)
# Test wrap correctness
i = 0
for sample in dataloader:
# test that the data being served is all zeros
self.assertTrue(sample["input"].nonzero(as_tuple=False).numel() == 0)
# test that it's all cuda tensors
for k in sample.keys():
self.assertTrue(sample[k].device.type == "cuda")
# check that consecutive samples are independent objects in memory
sample["input"].fill_(3.14)
# check that the expected number of samples is served
i += 1
self.assertEqual(i, NUM_SAMPLES)
|
ClassyVision-main
|
test/dataloader_async_gpu_wrapper_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""Various test loaders."""
import os
import random
import unittest
from itertools import chain
def _circleci_parallelism(suite):
"""Allow for parallelism in CircleCI for speedier tests.."""
if int(os.environ.get("CIRCLE_NODE_TOTAL", 0)) <= 1:
# either not running on circleci, or we're not using parallelism.
return suite
# tests are automatically sorted by discover, so we will get the same ordering
# on all hosts.
total = int(os.environ["CIRCLE_NODE_TOTAL"])
index = int(os.environ["CIRCLE_NODE_INDEX"])
# right now each test is corresponds to a /file/. Certain files are slower than
# others, so we want to flatten it
tests = [testfile._tests for testfile in suite._tests]
tests = list(chain.from_iterable(tests))
random.Random(42).shuffle(tests)
tests = [t for i, t in enumerate(tests) if i % total == index]
return unittest.TestSuite(tests)
def unittests():
"""
Short tests.
Runs on CircleCI on every commit. Returns everything in the tests root directory.
"""
test_loader = unittest.TestLoader()
test_suite = test_loader.discover("test", pattern="*_test.py")
test_suite = _circleci_parallelism(test_suite)
return test_suite
if __name__ == "__main__":
runner = unittest.TextTestRunner()
runner.run(unittests())
|
ClassyVision-main
|
test/suites.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
StepWithFixedGammaParamScheduler,
)
class TestStepWithFixedGammaScheduler(unittest.TestCase):
_num_epochs = 12
def _get_valid_config(self):
return {
"name": "step_with_fixed_gamma",
"base_value": 1,
"gamma": 0.1,
"num_decays": 3,
"num_epochs": self._num_epochs,
}
def test_invalid_config(self):
config = self._get_valid_config()
# Invalid num epochs
bad_config = copy.deepcopy(config)
bad_config["num_epochs"] = -1
with self.assertRaises(ValueError):
StepWithFixedGammaParamScheduler.from_config(bad_config)
# Invalid num_decays
bad_config["num_decays"] = 0
with self.assertRaises(ValueError):
StepWithFixedGammaParamScheduler.from_config(bad_config)
# Invalid base_value
bad_config = copy.deepcopy(config)
bad_config["base_value"] = -0.01
with self.assertRaises(ValueError):
StepWithFixedGammaParamScheduler.from_config(bad_config)
# Invalid gamma
bad_config = copy.deepcopy(config)
bad_config["gamma"] = [2]
with self.assertRaises(ValueError):
StepWithFixedGammaParamScheduler.from_config(bad_config)
def test_scheduler(self):
config = self._get_valid_config()
scheduler = StepWithFixedGammaParamScheduler.from_config(config)
schedule = [
scheduler(epoch_num / self._num_epochs)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [
1,
1,
1,
0.1,
0.1,
0.1,
0.01,
0.01,
0.01,
0.001,
0.001,
0.001,
]
for param, expected_param in zip(schedule, expected_schedule):
self.assertAlmostEqual(param, expected_param)
def test_build_step_with_fixed_gamma_scheduler(self):
config = self._get_valid_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, StepWithFixedGammaParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_step_with_fixed_gamma_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
import shutil
import tempfile
import unittest
import torch
from classy_vision.dataset import build_dataset, ClassyDataset
from classy_vision.dataset.image_path_dataset import ImagePathDataset
from torchvision import transforms
def _sort_key(x):
# sorts x which could correspond to either (sample["input"], sample["target"]),
# or sample["input"]
if isinstance(x, tuple):
return x[0].tolist() + x[1].tolist()
else:
return x.tolist()
class TestImageDataset(unittest.TestCase):
def get_test_image_dataset(self):
config = {
"name": "synthetic_image",
"crop_size": 224,
"num_channels": 3,
"seed": 0,
"class_ratio": 0.5,
"num_samples": 100,
"batchsize_per_replica": 1,
"use_shuffle": False,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [{"name": "ToTensor"}],
"key": "input",
}
],
}
dataset = build_dataset(config)
return dataset
def setUp(self):
# create a base directory to write image files to
self.base_dir = tempfile.mkdtemp()
# create a dir to store images in the torchvision.ImageFolder format
self.torchvision_dir = f"{self.base_dir}/tv"
os.mkdir(self.torchvision_dir)
os.mkdir(f"{self.torchvision_dir}/0")
os.mkdir(f"{self.torchvision_dir}/1")
# create a dir to store images in the other format
self.other_dir = f"{self.base_dir}/other"
os.mkdir(self.other_dir)
def tearDown(self):
# delete all the temporary data created
shutil.rmtree(self.base_dir)
def get_dataset_config(self):
return {
"name": "image_path",
"batchsize_per_replica": 1,
"use_shuffle": False,
"num_samples": None,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [{"name": "ToTensor"}],
"key": "input",
}
],
}
def test_build_dataset(self):
config = self.get_dataset_config()
config["image_files"] = ["abc"]
dataset = build_dataset(config)
self.assertIsInstance(dataset, ClassyDataset)
# test invalid configs
# cannot pass both image_files and image_folder
config["image_folder"] = self.torchvision_dir
with self.assertRaises(Exception):
dataset = build_dataset(config)
# cannot skip both image_files and image_folder
config.pop("image_files")
config.pop("image_folder")
with self.assertRaises(Exception):
dataset = build_dataset(config)
def test_image_dataset(self):
image_files = []
inputs = []
targets = {}
dataloader = self.get_test_image_dataset().iterator()
for i, sample in enumerate(dataloader):
input = sample["input"]
target = sample["target"]
image = transforms.ToPILImage()(input.squeeze())
path = f"{self.torchvision_dir}/{target.item()}/{i}.png"
image_files.append(path)
image.save(path)
path = f"{self.other_dir}/{i}.png"
image.save(path)
inputs.append(input)
targets[input] = target
config = self.get_dataset_config()
config["image_files"] = image_files
# test the dataset using image_files
dataset = ImagePathDataset.from_config(config)
dataloader = dataset.iterator()
# the samples should be in the same order
for sample, expected_input in zip(dataloader, inputs):
self.assertTrue(torch.allclose(sample["input"], expected_input))
config.pop("image_files")
# test the dataset with image_folder of type torchvision.ImageFolder
config["image_folder"] = self.torchvision_dir
dataset = ImagePathDataset.from_config(config)
dataloader = dataset.iterator()
# the order doesn't matter, so we sort the results
# note that this test assumes that the target for directory 0 will be 0
for (input, target), (expected_input, expected_target) in zip(
sorted(
((sample["input"], sample["target"]) for sample in dataloader),
key=_sort_key,
),
sorted(targets.items(), key=_sort_key),
):
self.assertTrue(torch.allclose(input, expected_input))
self.assertEqual(target, expected_target)
# test the dataset with image_folder of the second type
config["image_folder"] = self.other_dir
dataset = ImagePathDataset.from_config(config)
dataloader = dataset.iterator()
# the order doesn't matter, so we sort the results
for input, expected_input in zip(
sorted((sample["input"] for sample in dataloader), key=_sort_key),
sorted(inputs, key=_sort_key),
):
self.assertTrue(torch.allclose(input, expected_input))
|
ClassyVision-main
|
test/dataset_image_path_dataset_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import torch
from classy_vision.models import build_model, ClassyModel
from test.generic.utils import compare_model_state
class TestResNeXt3D(unittest.TestCase):
def setUp(self):
model_config_template = {
"name": "resnext3d",
"input_key": "video",
"clip_crop_size": 112,
"skip_transformation_type": "postactivated_shortcut",
"frames_per_clip": 32,
"input_planes": 3,
"stem_name": "resnext3d_stem",
"stem_planes": 64,
"stem_temporal_kernel": 3,
"stage_planes": 64,
"num_groups": 1,
"width_per_group": 16,
"heads": [
{
"name": "fully_convolutional_linear",
"unique_id": "default_head",
"in_plane": 512,
"pool_size": (2, 7, 7),
"activation_func": "softmax",
"num_classes": 2,
}
],
}
pbt = "postactivated_bottleneck_transformation"
model_config_variants = [
# ResNeXt3D-34
{
"residual_transformation_type": "basic_transformation",
"num_blocks": [3, 4, 6, 3],
},
# ResNeXt3D-50
{"residual_transformation_type": pbt, "num_blocks": [3, 4, 6, 3]},
# ResNeXt3D-101
{"residual_transformation_type": pbt, "num_blocks": [3, 4, 23, 3]},
]
self.model_configs = []
for variant in model_config_variants:
model_config = copy.deepcopy(model_config_template)
model_config.update(variant)
block_idx = model_config["num_blocks"][-1]
# attach the head at the last block
model_config["heads"][0]["fork_block"] = "pathway0-stage4-block%d" % (
block_idx - 1
)
self.model_configs.append(model_config)
self.batchsize = 1
self.forward_pass_configs = {
"train": {
# input shape: N x C x T x H x W
"input": {"video": torch.rand(self.batchsize, 3, 16, 112, 112)},
"model": {
"stem_maxpool": False,
"stage_temporal_stride": [1, 2, 2, 2],
"stage_spatial_stride": [1, 2, 2, 2],
},
},
"test": {
"input": {"video": torch.rand(self.batchsize, 3, 16, 256, 320)},
"model": {
"stem_maxpool": True,
"stage_temporal_stride": [1, 2, 2, 2],
"stage_spatial_stride": [1, 2, 2, 2],
},
},
}
def test_build_model(self):
for model_config in self.model_configs:
model = build_model(model_config)
self.assertTrue(isinstance(model, ClassyModel))
def test_forward_pass(self):
for split, split_config in self.forward_pass_configs.items():
for model_config in self.model_configs:
forward_pass_model_config = copy.deepcopy(model_config)
forward_pass_model_config.update(split_config["model"])
num_classes = forward_pass_model_config["heads"][0]["num_classes"]
model = build_model(forward_pass_model_config)
model.train(split == "train")
out = model(split_config["input"])
self.assertEqual(out.size(), (self.batchsize, num_classes))
def test_set_classy_state_plain(self):
# We use the same model architecture to save and load a model state.
# This is a plain use case of `set_classy_state` method
for model_config in self.model_configs:
model = build_model(model_config)
model_state = model.get_classy_state()
model2 = build_model(model_config)
model2.set_classy_state(model_state)
model2_state = model2.get_classy_state()
compare_model_state(self, model_state, model2_state)
def _get_model_config_weight_inflation(self):
model_2d_config = {
"name": "resnext3d",
"frames_per_clip": 1,
"input_planes": 3,
"clip_crop_size": 224,
"skip_transformation_type": "postactivated_shortcut",
"residual_transformation_type": "postactivated_bottleneck_transformation",
"num_blocks": [3, 4, 6, 3],
"stem_name": "resnext3d_stem",
"stem_planes": 64,
"stem_temporal_kernel": 1,
"stem_spatial_kernel": 7,
"stem_maxpool": True,
"stage_planes": 256,
"stage_temporal_kernel_basis": [[1], [1], [1], [1]],
"temporal_conv_1x1": [True, True, True, True],
"stage_temporal_stride": [1, 1, 1, 1],
"stage_spatial_stride": [1, 2, 2, 2],
"num_groups": 1,
"width_per_group": 64,
"num_classes": 1000,
"zero_init_residual_transform": True,
"heads": [
{
"name": "fully_convolutional_linear",
"unique_id": "default_head",
"pool_size": [1, 7, 7],
"activation_func": "softmax",
"num_classes": 1000,
"fork_block": "pathway0-stage4-block2",
"in_plane": 2048,
"use_dropout": False,
}
],
}
model_3d_config = {
"name": "resnext3d",
"frames_per_clip": 8,
"input_planes": 3,
"clip_crop_size": 224,
"skip_transformation_type": "postactivated_shortcut",
"residual_transformation_type": "postactivated_bottleneck_transformation",
"num_blocks": [3, 4, 6, 3],
"input_key": "video",
"stem_name": "resnext3d_stem",
"stem_planes": 64,
"stem_temporal_kernel": 5,
"stem_spatial_kernel": 7,
"stem_maxpool": True,
"stage_planes": 256,
"stage_temporal_kernel_basis": [[3], [3, 1], [3, 1], [1, 3]],
"temporal_conv_1x1": [True, True, True, True],
"stage_temporal_stride": [1, 1, 1, 1],
"stage_spatial_stride": [1, 2, 2, 2],
"num_groups": 1,
"width_per_group": 64,
"num_classes": 1000,
"freeze_trunk": False,
"zero_init_residual_transform": True,
"heads": [
{
"name": "fully_convolutional_linear",
"unique_id": "default_head",
"pool_size": [8, 7, 7],
"activation_func": "softmax",
"num_classes": 1000,
"fork_block": "pathway0-stage4-block2",
"in_plane": 2048,
"use_dropout": True,
}
],
}
return model_2d_config, model_3d_config
def test_set_classy_state_weight_inflation(self):
# Get model state from a 2D ResNet model, inflate the 2D conv weights,
# and use them to initialize 3D conv weights. This is an advanced use of
# `set_classy_state` method.
model_2d_config, model_3d_config = self._get_model_config_weight_inflation()
model_2d = build_model(model_2d_config)
model_2d_state = model_2d.get_classy_state()
model_3d = build_model(model_3d_config)
model_3d.set_classy_state(model_2d_state)
model_3d_state = model_3d.get_classy_state()
for name, weight_2d in model_2d_state["model"]["trunk"].items():
weight_3d = model_3d_state["model"]["trunk"][name]
if weight_2d.dim() == 5:
# inflation only applies to conv weights
self.assertEqual(weight_3d.dim(), 5)
if weight_2d.shape[2] == 1 and weight_3d.shape[2] > 1:
weight_2d_inflated = (
weight_2d.repeat(1, 1, weight_3d.shape[2], 1, 1)
/ weight_3d.shape[2]
)
self.assertTrue(torch.equal(weight_3d, weight_2d_inflated))
def test_set_classy_state_weight_inflation_inconsistent_kernel_size(self):
# Get model state from a 2D ResNet model, inflate the 2D conv weights,
# and use them to initialize 3D conv weights.
model_2d_config, model_3d_config = self._get_model_config_weight_inflation()
# Modify conv kernel size in the stem layer of 2D model to 5, which is
# inconsistent with the kernel size 7 used in 3D model.
model_2d_config["stem_spatial_kernel"] = 5
model_2d = build_model(model_2d_config)
model_2d_state = model_2d.get_classy_state()
model_3d = build_model(model_3d_config)
with self.assertRaises(AssertionError):
model_3d.set_classy_state(model_2d_state)
|
ClassyVision-main
|
test/models_resnext3d_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from __future__ import absolute_import, division, print_function, unicode_literals
import json
import logging
import os
import subprocess
import tempfile
import unittest
from pathlib import Path
import classy_vision.optim # NOQA
import torch
import torch.distributed as dist
from classy_vision.optim.zero import ZeRO
from test.generic.config_utils import (
get_distributed_launch_cmd,
get_fast_test_task_config,
)
from test.generic.optim_test_util import TestOptimizer
def dist_init(rank, world_size, filename):
dist.init_process_group(
init_method="file://" + filename,
backend=dist.Backend.GLOO,
rank=rank,
world_size=world_size,
)
class TestOptimizerStateShardingIntegration(unittest.TestCase, TestOptimizer):
@staticmethod
def _maybe_destroy_dist():
if dist.is_initialized():
logging.debug("Destroy previous torch dist process group")
dist.destroy_process_group()
def setUp(self):
self._maybe_destroy_dist()
self.filename = tempfile.NamedTemporaryFile(delete=True).name
dist_init(0, 1, self.filename)
def tearDown(self):
self._maybe_destroy_dist()
def _get_config(self):
return {"name": "zero", "base_optimizer": {"name": "sgd"}, "num_epochs": 3}
def _instance_to_test(self):
return ZeRO
class TestOptimizerStateSharding(unittest.TestCase):
def setUp(self):
self.path = Path(__file__).parent.absolute()
# Save the task config file on disk
config = self._get_task_config()
with tempfile.NamedTemporaryFile(mode="w", delete=False) as file_io:
json.dump(config, file_io)
file_io.flush()
self.config_path = file_io.name
def tearDown(self):
if self.config_path is not None:
os.unlink(self.config_path)
def _get_task_config(self):
config = get_fast_test_task_config()
config["optimizer"] = {
"name": "zero",
"base_optimizer": {"name": "sgd", "momentum": 0.9},
}
return config
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_oss_sgd(self):
"""
Test that the optimizer is correctly instantiated and that a task can run
"""
num_processes = 2
cmd = get_distributed_launch_cmd(
num_processes=num_processes,
trainer_path=f"{Path(__file__).parent.absolute()}/../classy_train.py",
config_path=self.config_path,
)
result = subprocess.run(cmd, shell=True)
self.assertEqual(result.returncode, 0)
|
ClassyVision-main
|
test/optim_sharded_sgd_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
import torchvision.transforms as transforms
from classy_vision.dataset.transforms import (
build_transforms,
ClassyTransform,
register_transform,
)
from classy_vision.dataset.transforms.util import ImagenetNoAugmentTransform
@register_transform("resize")
class resize(ClassyTransform):
def __init__(self, size: int):
self.transform = transforms.Resize(size=size)
def __call__(self, img):
return self.transform(img)
@register_transform("center_crop")
class center_crop(ClassyTransform):
def __init__(self, size: int):
self.transform = transforms.CenterCrop(size=size)
def __call__(self, img):
return self.transform(img)
class DatasetTransformsTest(unittest.TestCase):
def get_test_image(self):
return transforms.ToPILImage()(torch.randn((3, 224, 224)))
def test_transforms(self):
input = self.get_test_image()
# reference transform which we will use to validate the built transforms
reference_transform = ImagenetNoAugmentTransform()
reference_output = reference_transform(input)
# test a registered transform
config = [{"name": "imagenet_no_augment"}]
transform = build_transforms(config)
output = transform(input)
self.assertTrue(torch.allclose(output, reference_output))
# test a transform built using torchvision transforms
config = [
{"name": "Resize", "size": 256},
{"name": "CenterCrop", "size": 224},
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
]
transform = build_transforms(config)
output = transform(input)
self.assertTrue(torch.allclose(output, reference_output))
# test a combination of registered and torchvision transforms
config = [
{"name": "resize", "size": 256},
{"name": "center_crop", "size": 224},
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
]
transform = build_transforms(config)
output = transform(input)
self.assertTrue(torch.allclose(output, reference_output))
|
ClassyVision-main
|
test/dataset_transforms_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
CosineParamScheduler,
)
class TestCosineScheduler(unittest.TestCase):
_num_epochs = 10
def _get_valid_decay_config(self):
return {"name": "cosine", "start_value": 0.1, "end_value": 0}
def _get_valid_decay_config_intermediate_values(self):
return [0.0976, 0.0905, 0.0794, 0.0655, 0.05, 0.0345, 0.0206, 0.0095, 0.0024]
def test_invalid_config(self):
# Invalid num epochs
config = self._get_valid_decay_config()
bad_config = copy.deepcopy(config)
# Invalid Base lr
del bad_config["start_value"]
with self.assertRaises((AssertionError, TypeError)):
CosineParamScheduler.from_config(bad_config)
# Invalid end_value
bad_config["start_value"] = config["start_value"]
del bad_config["end_value"]
with self.assertRaises((AssertionError, TypeError)):
CosineParamScheduler.from_config(bad_config)
def test_scheduler_as_decay(self):
config = self._get_valid_decay_config()
scheduler = CosineParamScheduler.from_config(config)
schedule = [
round(scheduler(epoch_num / self._num_epochs), 4)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [
config["start_value"]
] + self._get_valid_decay_config_intermediate_values()
self.assertEqual(schedule, expected_schedule)
def test_scheduler_as_warmup(self):
config = self._get_valid_decay_config()
# Swap start and end lr to change to warmup
tmp = config["start_value"]
config["start_value"] = config["end_value"]
config["end_value"] = tmp
scheduler = CosineParamScheduler.from_config(config)
schedule = [
round(scheduler(epoch_num / self._num_epochs), 4)
for epoch_num in range(self._num_epochs)
]
# Schedule should be decay reversed
expected_schedule = [config["start_value"]] + list(
reversed(self._get_valid_decay_config_intermediate_values())
)
self.assertEqual(schedule, expected_schedule)
def test_scheduler_warmup_decay_match(self):
decay_config = self._get_valid_decay_config()
decay_scheduler = CosineParamScheduler.from_config(decay_config)
warmup_config = copy.deepcopy(decay_config)
# Swap start and end lr to change to warmup
tmp = warmup_config["start_value"]
warmup_config["start_value"] = warmup_config["end_value"]
warmup_config["end_value"] = tmp
warmup_scheduler = CosineParamScheduler.from_config(warmup_config)
decay_schedule = [
round(decay_scheduler(epoch_num / 1000), 8) for epoch_num in range(1, 1000)
]
warmup_schedule = [
round(warmup_scheduler(epoch_num / 1000), 8) for epoch_num in range(1, 1000)
]
self.assertEqual(decay_schedule, list(reversed(warmup_schedule)))
def test_build_cosine_scheduler(self):
config = self._get_valid_decay_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, CosineParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_cosine_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.dataset.core.random_image_datasets import (
RandomImageBinaryClassDataset,
)
from classy_vision.dataset.transforms.autoaugment import ImagenetAutoAugment # noqa
from classy_vision.dataset.transforms.util import build_field_transform_default_imagenet
class AutoaugmentTransformTest(unittest.TestCase):
def get_test_image_dataset(self):
return RandomImageBinaryClassDataset(
crop_size=224, class_ratio=0.5, num_samples=100, seed=0
)
def test_imagenet_autoaugment_transform_no_errors(self):
"""
Tests that the imagenet autoaugment transform runs without any errors.
"""
dataset = self.get_test_image_dataset()
config = [{"name": "imagenet_autoaugment"}]
transform = build_field_transform_default_imagenet(config)
sample = dataset[0]
# test that imagenet autoaugment has been registered and runs without errors
transform(sample)
|
ClassyVision-main
|
test/dataset_transforms_autoaugment_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import shutil
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path
import classy_vision.generic.util as util
import torch
import torch.nn as nn
from classy_vision.generic.util import (
CHECKPOINT_FILE,
get_torch_version,
load_checkpoint,
save_checkpoint,
split_batchnorm_params,
Timer,
update_classy_model,
update_classy_state,
)
from classy_vision.models import build_model
from classy_vision.tasks import build_task
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_fast_test_task_config, get_test_model_configs
from test.generic.utils import compare_model_state, compare_states
ROOT = Path(__file__).parent
@mock.patch("torch.tensor")
def get_mock_tensor(mock_class):
def get_cuda_tensor():
t = torch.tensor([1, 2, 3])
t.is_cuda = True
return t
mock_class.return_value.cuda.return_value = get_cuda_tensor()
mock_class.is_cuda = False
return torch.tensor([1, 2, 3])
class TestUtilMethods(unittest.TestCase):
class StructuredInput:
def __init__(self, tensor_a, tensor_b):
self.tensor_a = tensor_a
self.tensor_b = tensor_b
def to(self, device, non_blocking):
return TestUtilMethods.StructuredInput(
tensor_a=self.tensor_a.to(device=device, non_blocking=non_blocking),
tensor_b=self.tensor_b.to(device=device, non_blocking=non_blocking),
)
def test_recursive_copy_to_gpu(self):
tensor_a = get_mock_tensor()
tensor_b = get_mock_tensor()
tensor_structured = TestUtilMethods.StructuredInput(
tensor_a=get_mock_tensor(), tensor_b=get_mock_tensor()
)
valid_gpu_copy_value = tensor_a
gpu_value = util.recursive_copy_to_gpu(valid_gpu_copy_value)
self.assertTrue(gpu_value.is_cuda)
valid_recursive_copy_value = [[tensor_a]]
gpu_value = util.recursive_copy_to_gpu(valid_recursive_copy_value)
self.assertTrue(gpu_value[0][0].is_cuda)
valid_gpu_copy_collections = [
(tensor_a, tensor_b),
[tensor_a, tensor_b],
{"tensor_a": tensor_a, "tensor_b": tensor_b},
]
for value in valid_gpu_copy_collections:
gpu_value = util.recursive_copy_to_gpu(value)
if isinstance(value, dict):
self.assertTrue(gpu_value["tensor_a"].is_cuda)
self.assertTrue(gpu_value["tensor_b"].is_cuda)
else:
self.assertEqual(len(gpu_value), 2)
self.assertTrue(gpu_value[0].is_cuda)
self.assertTrue(gpu_value[1].is_cuda)
value = {"a": "b"}
self.assertEqual(value, util.recursive_copy_to_gpu(value))
valid_gpu_copy_structured = tensor_structured
gpu_value = util.recursive_copy_to_gpu(valid_gpu_copy_structured)
self.assertTrue(gpu_value.tensor_a.is_cuda)
self.assertTrue(gpu_value.tensor_b.is_cuda)
_json_config_file = ROOT / "generic_util_json_blob_test.json"
def _get_config(self):
return {
"name": "test_task",
"num_epochs": 12,
"loss": {"name": "test_loss"},
"dataset": {
"name": "test_data",
"batchsize_per_replica": 8,
"use_pairs": False,
"num_samples": None,
"use_shuffle": {"train": True, "test": False},
},
"meters": [{"name": "test_meter", "test_param": 0.1}],
"model": {"name": "test_model", "architecture": [1, 2, 3, 4]},
"optimizer": {
"name": "test_optimizer",
"test_param": {
"name": "test_scheduler",
"values": [0.1, 0.01, 0.001, 0.0001],
},
},
}
def test_load_config(self):
expected_config = self._get_config()
config = util.load_json(self._json_config_file)
self.assertEqual(config, expected_config)
def test_torch_seed(self):
# test that using util.torch_seed doesn't impact the generation of
# random numbers outside its context and that random numbers generated
# within its context are the same as setting a manual seed
torch.manual_seed(0)
torch.randn(10)
random_tensor_1 = torch.randn(10)
torch.manual_seed(0)
torch.randn(10)
with util.torch_seed(1):
random_tensor_2 = torch.randn(10)
self.assertTrue(torch.equal(torch.randn(10), random_tensor_1))
torch.manual_seed(1)
self.assertTrue(torch.equal(torch.randn(10), random_tensor_2))
def test_get_model_dummy_input(self):
for config in get_test_model_configs():
model = build_model(config) # pass in a dummy model for the cuda check
batchsize = 8
# input_key is list
input_key = ["audio", "video"]
input_shape = [[3, 40, 100], [4, 16, 223, 223]] # dummy input shapes
result = util.get_model_dummy_input(
model, input_shape, input_key, batchsize
)
self.assertEqual(result.keys(), {"audio", "video"})
for i in range(len(input_key)):
self.assertEqual(
result[input_key[i]].size(), tuple([batchsize] + input_shape[i])
)
# input_key is string
input_key = "video"
input_shape = [4, 16, 223, 223]
result = util.get_model_dummy_input(
model, input_shape, input_key, batchsize
)
self.assertEqual(result.keys(), {"video"})
self.assertEqual(result[input_key].size(), tuple([batchsize] + input_shape))
# input_key is None
input_key = None
input_shape = [4, 16, 223, 223]
result = util.get_model_dummy_input(
model, input_shape, input_key, batchsize
)
self.assertEqual(result.size(), tuple([batchsize] + input_shape))
def _compare_model_train_mode(self, model_1, model_2):
for name_1, module_1 in model_1.named_modules():
found = False
for name_2, module_2 in model_2.named_modules():
if name_1 == name_2:
found = True
if module_1.training != module_2.training:
return False
if not found:
return False
return True
def _check_model_train_mode(self, model, expected_mode):
for module in model.modules():
if module.training != expected_mode:
return False
return True
def test_split_batchnorm_params(self):
class MyModel(nn.Module):
def __init__(self):
super().__init__()
self.lin = nn.Linear(2, 3, bias=False)
self.relu = nn.ReLU()
self.bn = nn.BatchNorm1d(3)
def forward(self, x):
return self.bn(self.relu(self.lin(x)))
torch.manual_seed(1)
model = MyModel()
bn_params, lin_params = split_batchnorm_params(model)
self.assertEquals(len(bn_params), 2)
self.assertEquals(len(lin_params), 1)
self.assertTrue(torch.allclose(bn_params[0], model.bn.weight))
self.assertTrue(torch.allclose(bn_params[1], model.bn.bias))
self.assertTrue(torch.allclose(lin_params[0], model.lin.weight))
def test_train_model_eval_model(self):
class TestModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(1, 2)
self.dropout = nn.Dropout()
self.seq = nn.Sequential(
nn.ReLU(), nn.Conv2d(1, 2, 3), nn.BatchNorm2d(1, 2)
)
test_model = TestModel()
for train in [True, False]:
test_model.train(train)
# flip some of the modes
test_model.dropout.train(not train)
test_model.seq[1].train(not train)
orig_model = copy.deepcopy(test_model)
with util.train_model(test_model):
self._check_model_train_mode(test_model, True)
# the modes should be different inside the context manager
self.assertFalse(self._compare_model_train_mode(orig_model, test_model))
self.assertTrue(self._compare_model_train_mode(orig_model, test_model))
with util.eval_model(test_model):
self._check_model_train_mode(test_model, False)
# the modes should be different inside the context manager
self.assertFalse(self._compare_model_train_mode(orig_model, test_model))
self.assertTrue(self._compare_model_train_mode(orig_model, test_model))
@mock.patch("time.perf_counter")
def test_timer(self, mock_perf_counter: mock.MagicMock):
def test_func(a, b=2):
return a + b
start_time = 10
end_time = 12
mock_perf_counter.side_effect = [start_time, end_time]
with Timer() as timer:
test_func(1, b=3)
self.assertAlmostEqual(timer.elapsed_time, end_time - start_time)
class TestUpdateStateFunctions(unittest.TestCase):
def _compare_states(self, state_1, state_2, check_heads=True):
compare_states(self, state_1, state_2)
def _compare_model_state(self, state_1, state_2, check_heads=True):
return compare_model_state(self, state_1, state_2, check_heads=check_heads)
def test_update_classy_state(self):
"""
Tests that the update_classy_state successfully updates from a
checkpoint
"""
config = get_fast_test_task_config()
task = build_task(config)
task_2 = build_task(config)
task_2.prepare()
trainer = LocalTrainer()
trainer.train(task)
update_classy_state(task_2, task.get_classy_state(deep_copy=True))
self._compare_states(task.get_classy_state(), task_2.get_classy_state())
def test_update_classy_model(self):
"""
Tests that the update_classy_model successfully updates from a
checkpoint
"""
config = get_fast_test_task_config()
task = build_task(config)
trainer = LocalTrainer()
trainer.train(task)
for reset_heads in [False, True]:
task_2 = build_task(config)
# prepare task_2 for the right device
task_2.prepare()
update_classy_model(
task_2.model, task.model.get_classy_state(deep_copy=True), reset_heads
)
self._compare_model_state(
task.model.get_classy_state(),
task_2.model.get_classy_state(),
check_heads=not reset_heads,
)
if reset_heads:
# the model head states should be different
with self.assertRaises(Exception):
self._compare_model_state(
task.model.get_classy_state(),
task_2.model.get_classy_state(),
check_heads=True,
)
class TestCheckpointFunctions(unittest.TestCase):
def setUp(self):
# create a base directory to write checkpoints to
self.base_dir = tempfile.mkdtemp()
def tearDown(self):
# delete all the temporary data created
shutil.rmtree(self.base_dir)
def test_save_and_load_checkpoint(self):
checkpoint_dict = {str(i): i * 2 for i in range(1000)}
# save to the default checkpoint file
save_checkpoint(self.base_dir, checkpoint_dict)
# load the checkpoint by using the default file
loaded_checkpoint = load_checkpoint(self.base_dir)
self.assertDictEqual(checkpoint_dict, loaded_checkpoint)
# load the checkpoint by passing the full path
checkpoint_path = f"{self.base_dir}/{CHECKPOINT_FILE}"
loaded_checkpoint = load_checkpoint(checkpoint_path)
self.assertDictEqual(checkpoint_dict, loaded_checkpoint)
# create a new checkpoint dict
filename = "my_checkpoint.torch"
checkpoint_dict = {str(i): i * 3 for i in range(1000)}
# save the checkpoint to a different file
save_checkpoint(self.base_dir, checkpoint_dict, checkpoint_file=filename)
# load the checkpoint by passing the full path
checkpoint_path = f"{self.base_dir}/{filename}"
loaded_checkpoint = load_checkpoint(checkpoint_path)
self.assertDictEqual(checkpoint_dict, loaded_checkpoint)
@mock.patch("classy_vision.generic.util.torch")
def test_get_torch_version(self, mock_torch: mock.MagicMock):
mock_torch.__version__ = "1.7.2"
self.assertEqual(get_torch_version(), [1, 7])
self.assertLess(get_torch_version(), [1, 8])
self.assertGreater(get_torch_version(), [1, 6])
mock_torch.__version__ = "1.11.2a"
self.assertEqual(get_torch_version(), [1, 11])
self.assertLess(get_torch_version(), [1, 13])
self.assertGreater(get_torch_version(), [1, 8])
|
ClassyVision-main
|
test/generic_util_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.optim.adam import Adam
from test.generic.optim_test_util import TestOptimizer
class TestAdamOptimizer(TestOptimizer, unittest.TestCase):
def _check_momentum_buffer(self):
return False
def _get_config(self):
return {
"name": "adam",
"num_epochs": 90,
"lr": 0.1,
"betas": (0.9, 0.99),
"eps": 1e-8,
"weight_decay": 0.0001,
"amsgrad": False,
}
def _instance_to_test(self):
return Adam
|
ClassyVision-main
|
test/optim_adam_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import collections
import unittest
import torch
import torchvision.models
from classy_vision.generic.util import get_torch_version
from classy_vision.models import build_model, ResNeXt
from test.generic.utils import compare_model_state
MODELS = {
"small_resnext": {
"name": "resnext",
"num_blocks": [1, 1, 1, 1],
"init_planes": 4,
"reduction": 4,
"base_width_and_cardinality": [2, 32],
"small_input": True,
"zero_init_bn_residuals": True,
"basic_layer": True,
"final_bn_relu": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-0",
"in_plane": 128,
}
],
},
"small_resnet": {
"name": "resnet",
"num_blocks": [1, 1, 1, 1],
"init_planes": 4,
"reduction": 4,
"small_input": True,
"zero_init_bn_residuals": True,
"basic_layer": True,
"final_bn_relu": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-0",
"in_plane": 128,
}
],
},
"small_resnet_se": {
"name": "resnet",
"num_blocks": [1, 1, 1, 1],
"init_planes": 4,
"reduction": 4,
"small_input": True,
"zero_init_bn_residuals": True,
"basic_layer": True,
"final_bn_relu": True,
"use_se": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-0",
"in_plane": 128,
}
],
},
}
def _find_block_full_path(model, block_name):
"""Find the full path for a given block name
e.g. block3-1 --> 3.block3-1
"""
for name, _ in model.named_modules():
if name.endswith(block_name):
return name
return None
def _post_training_quantize(model, input):
if get_torch_version() >= [1, 11]:
import torch.ao.quantization as tq
from torch.ao.quantization.quantize_fx import convert_fx, prepare_fx
else:
import torch.quantization as tq
from torch.quantization.quantize_fx import convert_fx, prepare_fx
model.eval()
fqn_to_example_inputs = None
if get_torch_version() >= [1, 13]:
from torch.ao.quantization.utils import get_fqn_to_example_inputs
fqn_to_example_inputs = get_fqn_to_example_inputs(model, (input,))
heads = model.get_heads()
# since prepare changes the code of ClassyBlock we need to clear head first
# and reattach it later to avoid caching
model.clear_heads()
prepare_custom_config_dict = {}
head_path_from_blocks = [
_find_block_full_path(model.blocks, block_name) for block_name in heads.keys()
]
# we need to keep the modules used in head standalone since
# it will be accessed with path name directly in execution
if get_torch_version() >= [1, 13]:
prepare_custom_config_dict["standalone_module_name"] = [
(
head,
tq.get_default_qconfig_mapping("fbgemm"),
fqn_to_example_inputs["blocks." + head],
{"input_quantized_idxs": [0], "output_quantized_idxs": []},
None,
)
for head in head_path_from_blocks
]
else:
standalone_example_inputs = (torch.rand(1, 3, 3, 3),)
prepare_custom_config_dict["standalone_module_name"] = [
(
head,
{"": tq.default_qconfig},
standalone_example_inputs,
{"input_quantized_idxs": [0], "output_quantized_idxs": []},
None,
)
for head in head_path_from_blocks
]
example_inputs = (torch.rand(1, 3, 3, 3),)
if get_torch_version() >= [1, 13]:
example_inputs = fqn_to_example_inputs["initial_block"]
model.initial_block = prepare_fx(
model.initial_block, tq.get_default_qconfig_mapping("fbgemm"), example_inputs
)
if get_torch_version() >= [1, 13]:
example_inputs = fqn_to_example_inputs["blocks"]
model.blocks = prepare_fx(
model.blocks,
tq.get_default_qconfig_mapping("fbgemm"),
example_inputs,
prepare_custom_config_dict,
)
model.set_heads(heads)
# calibration
model(input)
heads = model.get_heads()
model.clear_heads()
model.initial_block = convert_fx(model.initial_block)
model.blocks = convert_fx(model.blocks)
model.set_heads(heads)
return model
class TestResnext(unittest.TestCase):
def _test_model(self, model_config):
"""This test will build ResNeXt-* models, run a forward pass and
verify output shape, and then verify that get / set state
works.
I do this in one test so that we construct the model a minimum
number of times.
"""
model = build_model(model_config)
# Verify forward pass works
input = torch.ones([1, 3, 32, 32])
output = model.forward(input)
self.assertEqual(output.size(), (1, 1000))
# Verify get_set_state
new_model = build_model(model_config)
state = model.get_classy_state()
new_model.set_classy_state(state)
new_state = new_model.get_classy_state()
compare_model_state(self, state, new_state, check_heads=True)
def _test_quantize_model(self, model_config):
"""This test will build ResNeXt-* models, quantize the model
with fx graph mode quantization, run a forward pass and
verify output shape, and then verify that get / set state
works.
"""
model = build_model(model_config)
# Verify forward pass works
input = torch.ones([1, 3, 32, 32])
output = model.forward(input)
self.assertEqual(output.size(), (1, 1000))
model = _post_training_quantize(model, input)
# Verify forward pass works
input = torch.ones([1, 3, 32, 32])
output = model.forward(input)
self.assertEqual(output.size(), (1, 1000))
# Verify get_set_state
new_model = build_model(model_config)
new_model = _post_training_quantize(new_model, input)
state = model.get_classy_state()
new_model.set_classy_state(state)
# TODO: test get state for new_model and make sure
# it is the same as state,
# Currently allclose is not supported in quantized tensors
# so we can't check this right now
def test_build_preset_model(self):
configs = [
{"name": "resnet18", "use_se": True},
{
"name": "resnet50",
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-2",
"in_plane": 2048,
}
],
},
{
"name": "resnext50_32x4d",
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-2",
"in_plane": 2048,
}
],
},
]
for config in configs:
model = build_model(config)
self.assertIsInstance(model, ResNeXt)
def test_small_resnext(self):
self._test_model(MODELS["small_resnext"])
@unittest.skipIf(
get_torch_version() < [1, 13],
"This test is using a new api of FX Graph Mode Quantization which is only available after 1.13",
)
def test_quantized_small_resnext(self):
self._test_quantize_model(MODELS["small_resnext"])
def test_small_resnet(self):
self._test_model(MODELS["small_resnet"])
@unittest.skipIf(
get_torch_version() < [1, 13],
"This test is using a new api of FX Graph Mode Quantization which is only available after 1.13",
)
def test_quantized_small_resnet(self):
self._test_quantize_model(MODELS["small_resnet"])
def test_small_resnet_se(self):
self._test_model(MODELS["small_resnet_se"])
@unittest.skipIf(
get_torch_version() < [1, 13],
"This test is using a new api of FX Graph Mode Quantization which is only available after 1.13",
)
def test_quantized_small_resnet_se(self):
self._test_quantize_model(MODELS["small_resnet_se"])
class TestTorchvisionEquivalence(unittest.TestCase):
@staticmethod
def tensor_sizes(state):
size_count = collections.defaultdict(int)
for key, value in state.items():
if key.startswith("fc."):
continue # "head" for torchvision
size_count[value.size()] += 1
return dict(size_count)
def assert_tensor_sizes_match_torchvision(self, model_name):
classy_model = build_model({"name": model_name})
torchvision_model = getattr(torchvision.models, model_name)(pretrained=False)
classy_sizes = self.tensor_sizes(
classy_model.get_classy_state()["model"]["trunk"]
)
torchvision_sizes = self.tensor_sizes(torchvision_model.state_dict())
self.assertEqual(
classy_sizes,
torchvision_sizes,
f"{model_name} tensor shapes do not match torchvision",
)
def test_resnet18(self):
"""Resnet18 tensor shapes should match torchvision."""
self.assert_tensor_sizes_match_torchvision("resnet18")
def test_resnet34(self):
"""Resnet34 tensor shapes should match torchvision."""
self.assert_tensor_sizes_match_torchvision("resnet34")
def test_resnet50(self):
"""Resnet50 tensor shapes should match torchvision."""
self.assert_tensor_sizes_match_torchvision("resnet50")
def test_resnext50_32x4d(self):
"""Resnext50_32x4d tensor shapes should match torchvision."""
self.assert_tensor_sizes_match_torchvision("resnext50_32x4d")
|
ClassyVision-main
|
test/models_resnext_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.dataset.core.random_image_datasets import (
RandomImageBinaryClassDataset,
)
from classy_vision.dataset.transforms.util import build_field_transform_default_imagenet
class LightingTransformTest(unittest.TestCase):
def get_test_image_dataset(self):
return RandomImageBinaryClassDataset(
crop_size=224, class_ratio=0.5, num_samples=100, seed=0
)
def test_lighting_transform_no_errors(self):
"""
Tests that the lighting transform runs without any errors.
"""
dataset = self.get_test_image_dataset()
config = [{"name": "ToTensor"}, {"name": "lighting"}]
transform = build_field_transform_default_imagenet(config)
sample = dataset[0]
try:
# test that lighting has been registered and runs without errors
transform(sample)
except Exception:
self.fail("LightingTransform raised an exception")
return
|
ClassyVision-main
|
test/dataset_transforms_lighting_transform_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import unittest.mock as mock
from itertools import product
from classy_vision.hooks import ClassyHook, LossLrMeterLoggingHook
from classy_vision.optim.param_scheduler import ClassyParamScheduler, UpdateInterval
from classy_vision.tasks import build_task, ClassyTask
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_test_mlp_task_config, get_test_task_config
from test.generic.hook_test_utils import HookTestBase
class TestLossLrMeterLoggingHook(HookTestBase):
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {"log_freq": 1}
invalid_config = copy.deepcopy(config)
invalid_config["log_freq"] = "this is not an int"
self.constructor_test_helper(
config=config,
hook_type=LossLrMeterLoggingHook,
hook_registry_name="loss_lr_meter_logging",
invalid_configs=[invalid_config],
)
@mock.patch("classy_vision.hooks.loss_lr_meter_logging_hook.get_rank")
def test_logging(self, mock_get_rank: mock.MagicMock) -> None:
"""
Test that the logging happens as expected and the loss and lr values are
correct.
"""
rank = 5
mock_get_rank.return_value = rank
# set up the task and state
config = get_test_task_config()
config["dataset"]["train"]["batchsize_per_replica"] = 2
config["dataset"]["test"]["batchsize_per_replica"] = 5
task = build_task(config)
task.prepare()
task.on_start()
task.on_phase_start()
losses = [1.2, 2.3, 3.4, 4.5]
task.phase_idx = 0
for log_freq in [5, None]:
# create a loss lr meter hook
loss_lr_meter_hook = LossLrMeterLoggingHook(log_freq=log_freq)
# check that _log_loss_lr_meters() is called after on_step() every
# log_freq batches and after on_phase_end()
with mock.patch.object(
loss_lr_meter_hook, "_log_loss_lr_meters"
) as mock_fn:
num_batches = 20
for i in range(num_batches):
task.losses = list(range(i))
loss_lr_meter_hook.on_step(task)
if log_freq is not None and i and i % log_freq == 0:
mock_fn.assert_called()
mock_fn.reset_mock()
continue
mock_fn.assert_not_called()
loss_lr_meter_hook.on_phase_end(task)
mock_fn.assert_called()
# test _log_loss_lr_meters()
task.losses = losses
with self.assertLogs():
loss_lr_meter_hook._log_loss_lr_meters(task)
task.phase_idx += 1
def test_logged_lr(self):
class SchedulerMock(ClassyParamScheduler):
def __call__(self, where):
return where
mock_lr_scheduler = SchedulerMock(UpdateInterval.STEP)
config = get_test_mlp_task_config()
config["num_epochs"] = 3
config["dataset"]["train"]["batchsize_per_replica"] = 10
config["dataset"]["test"]["batchsize_per_replica"] = 5
task = build_task(config)
task.set_optimizer_schedulers({"lr": mock_lr_scheduler})
trainer = LocalTrainer()
# 2 LR updates per epoch = 6
lr_order = [0.0, 1 / 6, 2 / 6, 3 / 6, 4 / 6, 5 / 6]
lr_list = []
class LRLoggingHook(ClassyHook):
on_end = ClassyHook._noop
on_phase_end = ClassyHook._noop
on_phase_start = ClassyHook._noop
on_start = ClassyHook._noop
def on_step(self, task):
if task.train:
lr_list.append(task.optimizer.options_view.lr)
hook = LRLoggingHook()
task.set_hooks([hook])
trainer.train(task)
self.assertEqual(lr_list, lr_order)
|
ClassyVision-main
|
test/hooks_loss_lr_meter_logging_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import random
import unittest
import numpy
import torch
import torchvision.transforms as transforms
from classy_vision.dataset.core.random_image_datasets import (
RandomImageBinaryClassDataset,
SampleType,
)
from classy_vision.dataset.transforms import build_transforms
from classy_vision.dataset.transforms.util import (
build_field_transform_default_imagenet,
GenericImageTransform,
ImagenetAugmentTransform,
ImagenetNoAugmentTransform,
)
def _apply_transform_to_key_and_copy(sample, transform, key, seed=0):
"""
This helper function takes a sample, makes a copy, applies the
provided transform to the appropriate key in the copied sample and
returns the copy. It's solely to help make sure the copying /
random seed happens correctly throughout the file.
It is useful for constructing the expected sample field in the
transform checks.
"""
expected_sample = copy.deepcopy(sample)
torch.manual_seed(seed)
numpy.random.seed(seed)
random.seed(seed)
is_tuple = False
if isinstance(expected_sample, tuple):
expected_sample = list(expected_sample)
is_tuple = True
expected_sample[key] = transform(expected_sample[key])
return tuple(expected_sample) if is_tuple else expected_sample
class DatasetTransformsUtilTest(unittest.TestCase):
def get_test_image_dataset(self, sample_type):
return RandomImageBinaryClassDataset(
crop_size=224,
class_ratio=0.5,
num_samples=100,
seed=0,
sample_type=sample_type,
)
def transform_checks(self, sample, transform, expected_sample, seed=0):
"""
This helper function applies the transform to the sample
and verifies that the output is the expected_sample. The
sole purpose is to make sure copying / random seed / checking
all of the fields in the sample happens correctly.
"""
transformed_sample = copy.deepcopy(sample)
torch.manual_seed(seed)
numpy.random.seed(seed)
random.seed(seed)
transformed_sample = transform(transformed_sample)
if isinstance(expected_sample, (tuple, list)):
for transformed, exp in zip(transformed_sample, expected_sample):
if torch.is_tensor(exp):
self.assertTrue(torch.allclose(transformed, exp))
if isinstance(expected_sample, dict):
for key, exp_val in expected_sample.items():
self.assertTrue(key in transformed_sample)
if torch.is_tensor(exp_val):
self.assertTrue(torch.allclose(transformed_sample[key], exp_val))
elif isinstance(exp_val, float):
self.assertAlmostEqual(transformed_sample[key], exp_val)
else:
self.assertEqual(transformed_sample[key], exp_val)
def test_build_dict_field_transform_default_imagenet(self):
dataset = self.get_test_image_dataset(SampleType.DICT)
# should apply the transform in the config
config = [{"name": "ToTensor"}]
default_transform = transforms.Compose(
[transforms.CenterCrop(100), transforms.ToTensor()]
)
transform = build_field_transform_default_imagenet(
config, default_transform=default_transform
)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
sample, transforms.ToTensor(), "input"
)
self.transform_checks(sample, transform, expected_sample)
# should apply default_transform
config = None
transform = build_field_transform_default_imagenet(
config, default_transform=default_transform
)
expected_sample = _apply_transform_to_key_and_copy(
sample, default_transform, "input"
)
self.transform_checks(sample, transform, expected_sample)
# should apply the transform for a test split
transform = build_field_transform_default_imagenet(config, split="test")
expected_sample = _apply_transform_to_key_and_copy(
sample, ImagenetNoAugmentTransform(), "input"
)
self.transform_checks(sample, transform, expected_sample)
def test_build_tuple_field_transform_default_imagenet(self):
dataset = self.get_test_image_dataset(SampleType.TUPLE)
# should apply the transform in the config
config = [{"name": "ToTensor"}]
default_transform = transforms.Compose(
[transforms.CenterCrop(100), transforms.ToTensor()]
)
transform = build_field_transform_default_imagenet(
config, default_transform=default_transform, key=0, key_map_transform=None
)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
sample, transforms.ToTensor(), 0
)
self.transform_checks(sample, transform, expected_sample)
# should apply default_transform
config = None
transform = build_field_transform_default_imagenet(
config, default_transform=default_transform, key=0, key_map_transform=None
)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(sample, default_transform, 0)
self.transform_checks(sample, transform, expected_sample)
# should apply the transform for a test split
transform = build_field_transform_default_imagenet(
config, split="test", key=0, key_map_transform=None
)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
sample, ImagenetNoAugmentTransform(), 0
)
self.transform_checks(sample, transform, expected_sample)
def test_apply_transform_to_key_from_config(self):
dataset = self.get_test_image_dataset(SampleType.DICT)
config = [
{
"name": "apply_transform_to_key",
"transforms": [{"name": "ToTensor"}],
"key": "input",
}
]
transform = build_transforms(config)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
sample, transforms.ToTensor(), "input"
)
self.transform_checks(sample, transform, expected_sample)
def test_generic_image_transform(self):
dataset = self.get_test_image_dataset(SampleType.TUPLE)
# Check constructor asserts
with self.assertRaises(AssertionError):
transform = GenericImageTransform(
split="train", transform=transforms.ToTensor()
)
transform = GenericImageTransform(split="valid", transform=None)
# Check class constructor
transform = GenericImageTransform(transform=None)
PIL_sample = dataset[0]
tensor_sample = (transforms.ToTensor()(PIL_sample[0]), PIL_sample[1])
expected_sample = {
"input": copy.deepcopy(tensor_sample[0]),
"target": copy.deepcopy(tensor_sample[1]),
}
self.transform_checks(tensor_sample, transform, expected_sample)
transform = GenericImageTransform(transform=transforms.ToTensor())
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
{"input": sample[0], "target": sample[1]}, transforms.ToTensor(), "input"
)
self.transform_checks(sample, transform, expected_sample)
transform = GenericImageTransform(split="train")
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
{"input": sample[0], "target": sample[1]},
ImagenetAugmentTransform(),
"input",
)
self.transform_checks(sample, transform, expected_sample)
transform = GenericImageTransform(split="test")
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
{"input": sample[0], "target": sample[1]},
ImagenetNoAugmentTransform(),
"input",
)
self.transform_checks(sample, transform, expected_sample)
# Check from_config constructor / registry
config = [
{"name": "generic_image_transform", "transforms": [{"name": "ToTensor"}]}
]
transform = build_transforms(config)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
{"input": sample[0], "target": sample[1]}, transforms.ToTensor(), "input"
)
self.transform_checks(sample, transform, expected_sample)
# Check with Imagenet defaults
config = [{"name": "generic_image_transform", "split": "train"}]
transform = build_transforms(config)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
{"input": sample[0], "target": sample[1]},
ImagenetAugmentTransform(),
"input",
)
self.transform_checks(sample, transform, expected_sample)
config = [{"name": "generic_image_transform", "split": "test"}]
transform = build_transforms(config)
sample = dataset[0]
expected_sample = _apply_transform_to_key_and_copy(
{"input": sample[0], "target": sample[1]},
ImagenetNoAugmentTransform(),
"input",
)
self.transform_checks(sample, transform, expected_sample)
|
ClassyVision-main
|
test/dataset_transforms_util_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.heads import build_head, ClassyHead, register_head
class TestClassyHead(unittest.TestCase):
@register_head("dummy_head")
class DummyHead(ClassyHead):
def __init__(self, unique_id, num_classes, in_plane):
super().__init__(unique_id, num_classes)
self.fc = torch.nn.Linear(in_plane, num_classes)
def forward(self, x):
return self.fc(x)
@classmethod
def from_config(cls, config):
return cls(config["unique_id"], config["num_classes"], config["in_plane"])
def _get_config(self):
return {
"name": "dummy_head",
"num_classes": 3,
"unique_id": "cortex_dummy_head",
"fork_block": "block3",
"in_plane": 2048,
}
def test_build_head(self):
config = self._get_config()
head = build_head(config)
self.assertEqual(head.unique_id, config["unique_id"])
del config["unique_id"]
with self.assertRaises(AssertionError):
head = build_head(config)
def test_forward(self):
config = self._get_config()
head = build_head(config)
input = torch.randn(1, config["in_plane"])
output = head(input)
self.assertEqual(output.size(), torch.Size([1, 3]))
def _get_pass_through_config(self):
return {
"name": "identity",
"num_classes": 3,
"unique_id": "cortex_pass_through_head",
"fork_block": "block3",
"in_plane": 4,
}
def test_identity_forward(self):
config = self._get_pass_through_config()
head = build_head(config)
input = torch.randn(1, config["in_plane"])
output = head(input)
self.assertEqual(input.size(), output.size())
self.assert_(torch.all(torch.eq(input, output)))
|
ClassyVision-main
|
test/classy_vision_head_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.generic.util import get_torch_version
from classy_vision.models import build_model, ClassyModel
class TestMLPModel(unittest.TestCase):
def test_build_model(self):
config = {"name": "mlp", "input_dim": 3, "output_dim": 1, "hidden_dims": [2]}
model = build_model(config)
self.assertTrue(isinstance(model, ClassyModel))
tensor = torch.tensor([[1, 2, 3]], dtype=torch.float)
output = model.forward(tensor)
self.assertEqual(output.shape, torch.Size([1, 1]))
tensor = torch.tensor([[1, 2, 3], [1, 2, 3]], dtype=torch.float)
output = model.forward(tensor)
self.assertEqual(output.shape, torch.Size([2, 1]))
@unittest.skipIf(
get_torch_version() < [1, 13],
"This test is using a new api of FX Graph Mode Quantization which is only available after 1.13",
)
def test_quantize_model(self):
import torch.ao.quantization as tq
from torch.ao.quantization.quantize_fx import convert_fx, prepare_fx
config = {"name": "mlp", "input_dim": 3, "output_dim": 1, "hidden_dims": [2]}
model = build_model(config)
self.assertTrue(isinstance(model, ClassyModel))
model.eval()
example_inputs = (torch.rand(1, 3),)
model.mlp = prepare_fx(model.mlp, {"": tq.default_qconfig}, example_inputs)
model.mlp = convert_fx(model.mlp)
tensor = torch.tensor([[1, 2, 3]], dtype=torch.float)
output = model.forward(tensor)
self.assertEqual(output.shape, torch.Size([1, 1]))
tensor = torch.tensor([[1, 2, 3], [1, 2, 3]], dtype=torch.float)
output = model.forward(tensor)
self.assertEqual(output.shape, torch.Size([2, 1]))
|
ClassyVision-main
|
test/models_mlp_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import importlib
import os
import shutil
import tempfile
import torch
from classy_vision.generic.util import load_checkpoint
from classy_vision.hooks import CheckpointHook
from classy_vision.tasks import build_task
from classy_vision.trainer import LocalTrainer
from fvcore.common import file_io
from fvcore.common.file_io import PathHandler, PathManager
from test.generic.config_utils import get_fast_test_task_config, get_test_task_config
from test.generic.hook_test_utils import HookTestBase
class TestException(Exception):
pass
class TestPathHandler(PathHandler):
PREFIX = "test://"
def _get_supported_prefixes(self):
return [self.PREFIX]
def _exists(self, *args, **kwargs):
return True
def _isdir(self, *args, **kwargs):
return True
def _open(self, *args, **kwargs):
raise TestException()
class TestCheckpointHook(HookTestBase):
def setUp(self) -> None:
self.base_dir = tempfile.mkdtemp()
def tearDown(self) -> None:
shutil.rmtree(self.base_dir)
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {
"checkpoint_folder": "/test/",
"input_args": {"foo": "bar"},
"phase_types": ["train"],
"checkpoint_period": 2,
}
invalid_config = copy.deepcopy(config)
invalid_config["checkpoint_folder"] = 12
self.constructor_test_helper(
config=config,
hook_type=CheckpointHook,
hook_registry_name="checkpoint",
invalid_configs=[invalid_config],
)
def test_failure(self) -> None:
self.assertFalse(PathManager.exists("test://foo"))
PathManager.register_handler(TestPathHandler())
# make sure that TestPathHandler is being used
self.assertTrue(PathManager.exists("test://foo"))
checkpoint_folder = "test://root"
checkpoint_hook = CheckpointHook(checkpoint_folder, {}, phase_types=["train"])
config = get_test_task_config()
task = build_task(config)
task.prepare()
# we should raise an exception while trying to save the checkpoint
with self.assertRaises(TestException):
checkpoint_hook.on_phase_end(task)
def test_state_checkpointing(self) -> None:
"""
Test that the state gets checkpointed without any errors, but only on the
right phase_type and only if the checkpoint directory exists.
"""
config = get_test_task_config()
task = build_task(config)
task.prepare()
checkpoint_folder = self.base_dir + "/checkpoint_end_test/"
input_args = {"foo": "bar"}
# create a checkpoint hook
checkpoint_hook = CheckpointHook(
checkpoint_folder, input_args, phase_types=["train"]
)
# checkpoint directory doesn't exist
# call the on start function
with self.assertRaises(FileNotFoundError):
checkpoint_hook.on_start(task)
# call the on end phase function
with self.assertRaises(AssertionError):
checkpoint_hook.on_phase_end(task)
# try loading a non-existent checkpoint
checkpoint = load_checkpoint(checkpoint_folder)
self.assertIsNone(checkpoint)
# create checkpoint dir, verify on_start hook runs
os.mkdir(checkpoint_folder)
checkpoint_hook.on_start(task)
# Phase_type is test, expect no checkpoint
task.train = False
# call the on end phase function
checkpoint_hook.on_phase_end(task)
checkpoint = load_checkpoint(checkpoint_folder)
self.assertIsNone(checkpoint)
task.train = True
# call the on end phase function
checkpoint_hook.on_phase_end(task)
# model should be checkpointed. load and compare
checkpoint = load_checkpoint(checkpoint_folder)
self.assertIsNotNone(checkpoint)
for key in ["input_args", "classy_state_dict"]:
self.assertIn(key, checkpoint)
# not testing for equality of classy_state_dict, that is tested in
# a separate test
self.assertDictEqual(checkpoint["input_args"], input_args)
def test_checkpoint_period(self) -> None:
"""
Test that the checkpoint_period works as expected.
"""
config = get_test_task_config()
task = build_task(config)
task.prepare()
checkpoint_folder = self.base_dir + "/checkpoint_end_test/"
checkpoint_period = 10
for phase_types in [["train"], ["train", "test"]]:
# create a checkpoint hook
checkpoint_hook = CheckpointHook(
checkpoint_folder,
{},
phase_types=phase_types,
checkpoint_period=checkpoint_period,
)
# create checkpoint dir
os.mkdir(checkpoint_folder)
# call the on start function
checkpoint_hook.on_start(task)
# shouldn't create any checkpoints until there are checkpoint_period
# phases which are in phase_types
count = 0
valid_phase_count = 0
while valid_phase_count < checkpoint_period - 1:
task.train = count % 2 == 0
# call the on end phase function
checkpoint_hook.on_phase_end(task)
checkpoint = load_checkpoint(checkpoint_folder)
self.assertIsNone(checkpoint)
valid_phase_count += 1 if task.phase_type in phase_types else 0
count += 1
# create a phase which is in phase_types
task.train = True
# call the on end phase function
checkpoint_hook.on_phase_end(task)
# model should be checkpointed. load and compare
checkpoint = load_checkpoint(checkpoint_folder)
self.assertIsNotNone(checkpoint)
# delete the checkpoint dir
shutil.rmtree(checkpoint_folder)
def test_checkpointing(self):
# make checkpoint directory
checkpoint_folder = self.base_dir + "/checkpoint/"
os.mkdir(checkpoint_folder)
config = get_fast_test_task_config()
cuda_available = torch.cuda.is_available()
task = build_task(config)
task.prepare()
# create a checkpoint hook
checkpoint_hook = CheckpointHook(checkpoint_folder, {}, phase_types=["train"])
# call the on end phase function
checkpoint_hook.on_phase_end(task)
# we should be able to train a task using the checkpoint on all available
# devices
for use_gpu in {False, cuda_available}:
# load the checkpoint
checkpoint = load_checkpoint(checkpoint_folder)
# create a new task
task = build_task(config)
# set the checkpoint
task._set_checkpoint_dict(checkpoint)
task.set_use_gpu(use_gpu)
# we should be able to run the trainer using the checkpoint
trainer = LocalTrainer()
trainer.train(task)
|
ClassyVision-main
|
test/hooks_checkpoint_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.dataset import build_dataset
from classy_vision.hooks import LossLrMeterLoggingHook
from classy_vision.losses import build_loss
from classy_vision.meters import AccuracyMeter
from classy_vision.models import build_model
from classy_vision.optim import build_optimizer, build_optimizer_schedulers
from classy_vision.tasks import ClassificationTask
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_test_mlp_task_config
class TestLocalTrainer(unittest.TestCase):
def test_training(self):
"""Checks we can train a small MLP model."""
config = get_test_mlp_task_config()
task = (
ClassificationTask()
.set_num_epochs(10)
.set_loss(build_loss(config["loss"]))
.set_model(build_model(config["model"]))
.set_optimizer(build_optimizer(config["optimizer"]))
.set_optimizer_schedulers(build_optimizer_schedulers(config["optimizer"]))
.set_meters([AccuracyMeter(topk=[1])])
.set_hooks([LossLrMeterLoggingHook()])
)
for split in ["train", "test"]:
dataset = build_dataset(config["dataset"][split])
task.set_dataset(dataset, split)
self.assertTrue(task is not None)
trainer = LocalTrainer()
trainer.train(task)
accuracy = task.meters[0].value["top_1"]
self.assertAlmostEqual(accuracy, 1.0)
|
ClassyVision-main
|
test/trainer_local_trainer_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import torch
from classy_vision.losses import build_loss, SoftTargetCrossEntropyLoss
class TestSoftTargetCrossEntropyLoss(unittest.TestCase):
def _get_config(self):
return {
"name": "soft_target_cross_entropy",
"ignore_index": -1,
"reduction": "mean",
}
def _get_outputs(self):
return torch.tensor([[1.0, 7.0, 0.0, 0.0, 2.0]])
def _get_targets(self):
return torch.tensor([[1, 0, 0, 0, 1]])
def _get_loss(self):
return 5.51097965
def test_build_soft_target_cross_entropy(self):
config = self._get_config()
crit = build_loss(config)
self.assertTrue(isinstance(crit, SoftTargetCrossEntropyLoss))
self.assertEqual(crit._ignore_index, -1)
self.assertEqual(crit._reduction, "mean")
def test_soft_target_cross_entropy(self):
config = self._get_config()
crit = SoftTargetCrossEntropyLoss.from_config(config)
outputs = self._get_outputs()
targets = self._get_targets()
self.assertAlmostEqual(crit(outputs, targets).item(), self._get_loss())
# Verify ignore index works
outputs = self._get_outputs()
targets = torch.tensor([[-1, 0, 0, 0, 1]])
self.assertAlmostEqual(crit(outputs, targets).item(), 5.01097918)
def test_soft_target_cross_entropy_none_reduction(self):
# reduction mode is "none"
config = self._get_config()
config["reduction"] = "none"
crit = SoftTargetCrossEntropyLoss.from_config(config)
outputs = torch.tensor([[1.0, 7.0, 0.0, 0.0, 2.0], [4.0, 2.0, 1.0, 6.0, 0.5]])
targets = torch.tensor([[1, 0, 0, 0, 1], [0, 1, 0, 1, 0]])
loss = crit(outputs, targets)
self.assertEqual(loss.numel(), outputs.size(0))
def test_soft_target_cross_entropy_integer_label(self):
config = self._get_config()
crit = SoftTargetCrossEntropyLoss.from_config(config)
outputs = self._get_outputs()
targets = torch.tensor([4])
self.assertAlmostEqual(crit(outputs, targets).item(), 5.01097918)
def test_unnormalized_soft_target_cross_entropy(self):
config = {
"name": "soft_target_cross_entropy",
"ignore_index": -1,
"reduction": "mean",
"normalize_targets": False,
}
crit = SoftTargetCrossEntropyLoss.from_config(config)
outputs = self._get_outputs()
targets = self._get_targets()
self.assertAlmostEqual(crit(outputs, targets).item(), 11.0219593)
# Verify ignore index works
outputs = self._get_outputs()
targets = torch.tensor([[-1, 0, 0, 0, 1]])
self.assertAlmostEqual(crit(outputs, targets).item(), 5.01097965)
def test_ignore_row(self):
# If a sample has no valid targets, it should be ignored in the reduction.
config = self._get_config()
crit = SoftTargetCrossEntropyLoss.from_config(config)
outputs = torch.tensor([[1.0, 7.0, 0.0, 0.0, 2.0], [4.0, 2.0, 1.0, 6.0, 0.5]])
targets = torch.tensor([[1, 0, 0, 0, 1], [-1, -1, -1, -1, -1]])
self.assertAlmostEqual(crit(outputs, targets).item(), self._get_loss())
def test_deep_copy(self):
config = self._get_config()
crit = build_loss(config)
self.assertTrue(isinstance(crit, SoftTargetCrossEntropyLoss))
outputs = self._get_outputs()
targets = self._get_targets()
crit(outputs, targets)
crit2 = copy.deepcopy(crit)
self.assertAlmostEqual(crit2(outputs, targets).item(), self._get_loss())
|
ClassyVision-main
|
test/losses_soft_target_cross_entropy_loss_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.generic.util import get_torch_version
from classy_vision.losses import build_loss
class CriterionsTest(unittest.TestCase):
"""
Test that build_transform is able to build torch losses correctly.
"""
def _test_loss(self, config, output, target, expected_loss):
# test that we are able to build losses from torch.nn.modules.loss
# and that they work correctly
crit = build_loss(config)
# test that the weights are set correctly
self.assertAlmostEqual(crit.weight.numpy().tolist(), [1.0, 1.0])
# test that the loss is computed correctly
self.assertAlmostEqual(crit(output, target).item(), expected_loss)
# verify ignore index works
if "ignore_index" in config:
if get_torch_version() < [1, 11]:
self.assertAlmostEqual(crit(output, torch.tensor([-1])).item(), 0.0)
else:
self.assertTrue(torch.isnan(crit(output, torch.tensor([-1]))).item())
def test_cross_entropy_loss(self):
"""
Test CrossEntropyLoss
"""
config = {
"name": "CrossEntropyLoss",
"weight": [1.0, 1.0],
"ignore_index": -1,
"reduction": "mean",
}
output = torch.tensor([[9.0, 1.0]])
target = torch.tensor([1])
expected_loss = 8.000335693359375
self._test_loss(config, output, target, expected_loss)
def test_bce_with_logits_loss(self):
"""
Test BCEWithLogitsLoss
"""
config = {
"name": "BCEWithLogitsLoss",
"weight": [1.0, 1.0],
"reduction": "mean",
}
output = torch.tensor([0.999, 0.999])
target = torch.tensor([1.0, 1.0])
expected_loss = 0.313530727260701
self._test_loss(config, output, target, expected_loss)
|
ClassyVision-main
|
test/losses_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from __future__ import absolute_import, division, print_function, unicode_literals
import pathlib
import sys
import unittest
import classy_vision
from classy_vision.dataset.transforms import GenericImageTransform
from classy_vision.optim import SGD
from classy_vision.optim.param_scheduler import LinearParamScheduler
from classy_vision.tasks import ClassificationTask
from classy_vision.trainer import LocalTrainer
from torchvision import transforms
# import the classes from the synthetic template
path = pathlib.Path(classy_vision.__file__).resolve().parent
synthetic_template_path = path / "templates" / "synthetic"
sys.path.append(str(synthetic_template_path))
from datasets.my_dataset import MyDataset # isort:skip
from losses.my_loss import MyLoss # isort:skip
from models.my_model import MyModel # isort:skip
# WARNING: The goal of this test is to use our public API as advertised in our
# tutorials and make sure everything trains successfully. If you break this
# test, make sure you also update our tutorials.
class APITest(unittest.TestCase):
def test_one(self):
train_dataset = MyDataset(
batchsize_per_replica=32,
shuffle=False,
transform=GenericImageTransform(
transform=transforms.Compose(
[
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
),
]
)
),
num_samples=100,
crop_size=224,
class_ratio=0.5,
seed=0,
)
test_dataset = MyDataset(
batchsize_per_replica=32,
shuffle=False,
transform=GenericImageTransform(
transform=transforms.Compose(
[
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(
mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
),
]
)
),
num_samples=100,
crop_size=224,
class_ratio=0.5,
seed=0,
)
model = MyModel()
loss = MyLoss()
optimizer = SGD(momentum=0.9, weight_decay=1e-4, nesterov=True)
task = (
ClassificationTask()
.set_model(model)
.set_dataset(train_dataset, "train")
.set_dataset(test_dataset, "test")
.set_loss(loss)
.set_optimizer(optimizer)
.set_optimizer_schedulers(
{"lr": LinearParamScheduler(start_value=0.01, end_value=0.009)}
)
.set_num_epochs(1)
)
trainer = LocalTrainer()
trainer.train(task)
|
ClassyVision-main
|
test/api_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import torch
from classy_vision.models import build_model
from test.generic.utils import compare_model_state
class TestVisionTransformer(unittest.TestCase):
def get_vit_b_16_224_config(self):
return {
"name": "vision_transformer",
"image_size": 224,
"patch_size": 16,
"hidden_dim": 768,
"mlp_dim": 3072,
"num_heads": 12,
"num_layers": 12,
"attention_dropout_rate": 0,
"dropout_rate": 0.1,
"heads": [
{
"name": "vision_transformer_head",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "trunk_output",
"in_plane": 768,
"hidden_dim": 3072,
}
],
}
def get_vitc_b_16_224_config(self):
return {
"name": "vision_transformer",
"image_size": 224,
"patch_size": 16,
"hidden_dim": 768,
"mlp_dim": 3072,
"num_heads": 12,
"num_layers": 12,
"conv_stem_layers": [
{"kernel": 3, "stride": 2, "out_channels": 64},
{"kernel": 3, "stride": 2, "out_channels": 128},
{"kernel": 3, "stride": 1, "out_channels": 128},
{"kernel": 3, "stride": 2, "out_channels": 256},
{"kernel": 3, "stride": 1, "out_channels": 256},
{"kernel": 3, "stride": 2, "out_channels": 512},
],
"attention_dropout_rate": 0,
"dropout_rate": 0.1,
"heads": [
{
"name": "vision_transformer_head",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "trunk_output",
"in_plane": 768,
"hidden_dim": 3072,
}
],
}
def get_vit_l_32_224_config(self):
return {
"name": "vision_transformer",
"image_size": 224,
"patch_size": 32,
"hidden_dim": 1024,
"mlp_dim": 4096,
"num_heads": 16,
"num_layers": 24,
"attention_dropout_rate": 0,
"dropout_rate": 0.1,
"heads": [
{
"name": "vision_transformer_head",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "trunk_output",
"in_plane": 1024,
"hidden_dim": 4096,
}
],
}
def _test_model(
self,
model_config,
image_size=224,
expected_out_dims=1000,
test_forward_pass=True,
):
model = build_model(model_config)
if not test_forward_pass:
return
# Verify forward pass works
input = torch.ones([2, 3, image_size, image_size])
output = model.forward(input)
self.assertEqual(output.size(), (2, expected_out_dims))
# Verify get_set_state
new_model = build_model(model_config)
state = model.get_classy_state()
new_model.set_classy_state(state)
new_state = new_model.get_classy_state()
compare_model_state(self, state, new_state, check_heads=True)
def test_vit_b_16_224(self):
self._test_model(self.get_vit_b_16_224_config())
def test_vitc_b_16_224(self):
self._test_model(self.get_vitc_b_16_224_config())
def test_vit_l_32_224(self):
# testing the forward pass is slow so we skip it
self._test_model(self.get_vit_l_32_224_config(), test_forward_pass=False)
def test_all_presets(self):
for model_name, image_size, expected_out_dims in [
("vit_b_32", 32, 768),
("vit_b_16", 64, 768),
("vit_l_32", 32, 1024),
("vit_l_16", 32, 1024),
("vit_h_14", 14, 1280),
]:
# testing the forward pass is slow so we skip it
self._test_model(
{"name": model_name, "image_size": image_size},
image_size,
expected_out_dims,
test_forward_pass=False,
)
def test_resolution_change(self):
vit_b_16_224_config = self.get_vit_b_16_224_config()
vit_b_16_896_config = copy.deepcopy(vit_b_16_224_config)
vit_b_16_896_config["image_size"] = 896
vit_b_16_224_model = build_model(vit_b_16_224_config)
vit_b_16_896_model = build_model(vit_b_16_896_config)
# test state transfer from both resolutions
vit_b_16_224_model.set_classy_state(vit_b_16_896_model.get_classy_state())
vit_b_16_896_model.set_classy_state(vit_b_16_224_model.get_classy_state())
vit_b_16_448_config = copy.deepcopy(vit_b_16_224_config)
vit_b_16_448_config["image_size"] = 448
vit_b_16_448_model = build_model(vit_b_16_448_config)
# downsampling from 896 -> 448 -> 224 should give similar results to 896 -> 224
vit_b_16_448_model.set_classy_state(vit_b_16_896_model.get_classy_state())
vit_b_16_224_model.set_classy_state(vit_b_16_448_model.get_classy_state())
vit_b_16_224_model_2 = build_model(vit_b_16_224_config)
vit_b_16_224_model_2.set_classy_state(vit_b_16_896_model.get_classy_state())
# we should have similar position embeddings in both models
state_1 = vit_b_16_224_model.get_classy_state()["model"]["trunk"][
"encoder.pos_embedding"
]
state_2 = vit_b_16_224_model_2.get_classy_state()["model"]["trunk"][
"encoder.pos_embedding"
]
diff = state_1 - state_2
self.assertLess(diff.norm() / min(state_1.norm(), state_2.norm()), 0.1)
|
ClassyVision-main
|
test/models_vision_transformer_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.tasks import build_task
from test.generic.config_utils import get_test_task_config
class TestDataloaderLimitWrapper(unittest.TestCase):
def _test_number_of_batches(self, data_iterator, expected_batches):
num_batches = 0
for _ in data_iterator:
num_batches += 1
self.assertEqual(num_batches, expected_batches)
def test_streaming_dataset(self):
"""
Test that streaming datasets return the correct number of batches, and that
the length is also calculated correctly.
"""
config = get_test_task_config()
dataset_config = {
"name": "synthetic_image_streaming",
"split": "train",
"crop_size": 224,
"class_ratio": 0.5,
"num_samples": 2000,
"length": 4000,
"seed": 0,
"batchsize_per_replica": 32,
"use_shuffle": True,
}
expected_batches = 62
config["dataset"]["train"] = dataset_config
task = build_task(config)
task.prepare()
task.advance_phase()
# test that the number of batches expected is correct
self.assertEqual(task.num_batches_per_phase, expected_batches)
# test that the data iterator returns the expected number of batches
data_iterator = task.data_iterator
self._test_number_of_batches(data_iterator, expected_batches)
# test that the dataloader can be rebuilt
task.build_dataloaders_for_current_phase()
task.create_data_iterators()
data_iterator = task.data_iterator
self._test_number_of_batches(data_iterator, expected_batches)
|
ClassyVision-main
|
test/dataset_dataloader_limit_wrapper_test.py
|
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from test.generic.utils import ClassyTestCase
class TestClassyTestCase(unittest.TestCase):
def test_assert_torch_all_close(self):
test_fixture = ClassyTestCase()
data = [1.1, 2.2]
tensor_1 = torch.Tensor(data)
# shouldn't raise an exception
tensor_2 = tensor_1
test_fixture.assertTorchAllClose(tensor_1, tensor_2)
# should fail because tensors are not close
tensor_2 = tensor_1 / 2
with self.assertRaises(AssertionError):
test_fixture.assertTorchAllClose(tensor_1, tensor_2)
# should fail because tensor_2 is not a tensor
tensor_2 = data
with self.assertRaises(AssertionError):
test_fixture.assertTorchAllClose(tensor_1, tensor_2)
# should fail because tensor_1 is not a tensor
tensor_1 = data
tensor_2 = torch.Tensor(data)
with self.assertRaises(AssertionError):
test_fixture.assertTorchAllClose(tensor_1, tensor_2)
|
ClassyVision-main
|
test/test_generic_utils_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import math
import unittest
import unittest.mock as mock
import torch
import torch.nn as nn
from classy_vision.hooks import ExponentialMovingAverageModelHook
from classy_vision.models import ClassyModel
from test.generic.hook_test_utils import HookTestBase
class TestModel(ClassyModel):
def __init__(self):
super().__init__()
self.fc = nn.Linear(10, 10)
self.bn = nn.BatchNorm1d(10)
def init_fc_weight(self):
nn.init.zeros_(self.fc.weight)
def update_fc_weight(self):
nn.init.ones_(self.fc.weight)
def forward(self, x):
return self.bn(self.fc(x))
class TestExponentialMovingAverageModelHook(HookTestBase):
def _map_device_string(self, device):
return "cuda" if device == "gpu" else "cpu"
def _test_exponential_moving_average_hook(self, model_device, hook_device):
task = mock.MagicMock()
model = TestModel().to(device=self._map_device_string(model_device))
task.base_model = model
task.train = True
decay = 0.5
num_updates = 10
model.init_fc_weight()
exponential_moving_average_hook = ExponentialMovingAverageModelHook(
decay=decay, device=hook_device
)
exponential_moving_average_hook.on_start(task)
exponential_moving_average_hook.on_phase_start(task)
# set the weights to all ones and simulate 10 updates
task.base_model.update_fc_weight()
fc_weight = model.fc.weight.clone()
for _ in range(num_updates):
exponential_moving_average_hook.on_step(task)
exponential_moving_average_hook.on_phase_end(task)
# the model weights shouldn't have changed
self.assertTrue(torch.allclose(model.fc.weight, fc_weight))
# simulate a test phase now
task.train = False
exponential_moving_average_hook.on_phase_start(task)
exponential_moving_average_hook.on_phase_end(task)
# the model weights should be updated to the ema weights
self.assertTrue(
torch.allclose(
model.fc.weight, fc_weight * (1 - math.pow(1 - decay, num_updates))
)
)
# simulate a train phase again
task.train = True
exponential_moving_average_hook.on_phase_start(task)
# the model weights should be back to the old value
self.assertTrue(torch.allclose(model.fc.weight, fc_weight))
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {"decay": 0.5, "consider_bn_buffers": True, "device": "cpu"}
invalid_config1 = copy.deepcopy(config)
del invalid_config1["decay"]
invalid_config2 = copy.deepcopy(config)
invalid_config2["device"] = "crazy_hardware"
self.constructor_test_helper(
config=config,
hook_type=ExponentialMovingAverageModelHook,
hook_registry_name="ema_model_weights",
invalid_configs=[invalid_config1, invalid_config2],
)
def test_get_model_state_iterator(self):
device = "gpu" if torch.cuda.is_available() else "cpu"
model = TestModel().to(device=self._map_device_string(device))
decay = 0.5
# test that we pick up the right parameters in the iterator
for consider_bn_buffers in [True, False]:
exponential_moving_average_hook = ExponentialMovingAverageModelHook(
decay=decay, consider_bn_buffers=consider_bn_buffers, device=device
)
iterable = exponential_moving_average_hook.get_model_state_iterator(model)
fc_found = False
bn_found = False
bn_buffer_found = False
for _, param in iterable:
if any(param is item for item in model.fc.parameters()):
fc_found = True
if any(param is item for item in model.bn.parameters()):
bn_found = True
if any(param is item for item in model.bn.buffers()):
bn_buffer_found = True
self.assertTrue(fc_found)
self.assertTrue(bn_found)
self.assertEqual(bn_buffer_found, consider_bn_buffers)
def test_exponential_moving_average_hook(self):
device = "gpu" if torch.cuda.is_available() else "cpu"
self._test_exponential_moving_average_hook(device, device)
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_mixed_devices(self):
"""Tests that the hook works when the model and hook's device are different"""
self._test_exponential_moving_average_hook("cpu", "gpu")
self._test_exponential_moving_average_hook("gpu", "cpu")
|
ClassyVision-main
|
test/hooks_exponential_moving_average_model_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from classy_vision import meters
from classy_vision.meters import PrecisionAtKMeter
from test.generic.meter_test_utils import ClassificationMeterTest
class TestPrecisionAtKMeter(ClassificationMeterTest):
def test_precision_meter_registry(self):
meter = meters.build_meter({"name": "precision_at_k", "topk": [1, 3]})
self.assertTrue(isinstance(meter, PrecisionAtKMeter))
def test_single_meter_update_and_reset(self):
"""
This test verifies that the meter works as expected on a single
update + reset + same single update.
"""
meter = PrecisionAtKMeter(topk=[1, 2])
# Batchsize = 3, num classes = 3, score is probability of class
model_output = torch.tensor(
[
[0.2, 0.4, 0.4], # top-1: 1/2, top-2: 1/2
[0.2, 0.65, 0.15], # top-1: 1, top-2: 1/0
[0.33, 0.33, 0.34], # top-1: 2, top-2: 2/0?1
]
)
# One-hot encoding, 1 = positive for class
# sample-1: 1, sample-2: 0, sample-3: 0,1,2
target = torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]])
# Note for ties, we select randomly, so we should not use ambiguous ties
expected_value = {"top_1": 2 / 3.0, "top_2": 4 / 6.0}
self.meter_update_and_reset_test(meter, model_output, target, expected_value)
def test_double_meter_update_and_reset(self):
meter = PrecisionAtKMeter(topk=[1, 2])
# Batchsize = 3, num classes = 3, score is probability of class
model_outputs = [
torch.tensor([[0.3, 0.4, 0.3], [0.2, 0.65, 0.15], [0.33, 0.33, 0.34]]),
torch.tensor([[0.05, 0.4, 0.05], [0.15, 0.65, 0.2], [0.4, 0.2, 0.4]]),
]
# One-hot encoding, 1 = positive for class
# batch-1: sample-1: 1, sample-2: 0, sample-3: 0,1,2
# batch-2: sample-1: 1, sample-2: 1, sample-3: 1
targets = [
torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]]),
torch.tensor([[0, 1, 0], [0, 1, 0], [0, 1, 0]]),
]
# First batch has top-1 precision of 2/3.0, top-2 precision of 4/6.0
# Second batch has top-1 precision of 2/3.0, top-2 precision of 2/6.0
expected_value = {"top_1": 4 / 6.0, "top_2": 6 / 12.0}
self.meter_update_and_reset_test(meter, model_outputs, targets, expected_value)
def test_meter_invalid_model_output(self):
meter = PrecisionAtKMeter(topk=[1, 2])
# This model output has 3 dimensions instead of expected 2
model_output = torch.tensor(
[[[0.33, 0.33, 0.34], [1, 2, 3]], [[-1, -3, -4], [-10, -90, -100]]]
)
target = torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]])
self.meter_invalid_meter_input_test(meter, model_output, target)
def test_meter_invalid_target(self):
meter = PrecisionAtKMeter(topk=[1, 2])
model_output = torch.tensor(
[
[0.2, 0.4, 0.4], # top-1: 1/2, top-2: 1/2
[0.2, 0.65, 0.15], # top-1: 1, top-2: 1/0
[0.33, 0.33, 0.34], # top-1: 2, top-2: 2/0/1
]
)
# Target shape is of length 3
target = torch.tensor([[[0, 1, 2]]])
self.meter_invalid_meter_input_test(meter, model_output, target)
def test_meter_invalid_topk(self):
meter = PrecisionAtKMeter(topk=[1, 5])
model_output = torch.tensor(
[
[0.2, 0.4, 0.4], # top-1: 1/2, top-2: 1/2
[0.2, 0.65, 0.15], # top-1: 1, top-2: 1/0
[0.33, 0.33, 0.34], # top-1: 2, top-2: 2/0/1
]
)
target = torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]])
self.meter_invalid_meter_input_test(meter, model_output, target)
def test_meter_get_set_classy_state_test(self):
# In this test we update meter0 with model_output0 & target0
# and we update meter1 with model_output1 & target1 then
# transfer the state from meter1 to meter0 and validate they
# give same expected value.
#
# Expected value is the expected value of meter1 For this test
# to work, top-1 / top-2 values of meter0 / meter1 should be
# different
meters = [PrecisionAtKMeter(topk=[1, 2]), PrecisionAtKMeter(topk=[1, 2])]
model_outputs = [
torch.tensor([[0.05, 0.4, 0.05], [0.2, 0.65, 0.15], [0.33, 0.33, 0.34]]),
torch.tensor([[0.05, 0.4, 0.05], [0.15, 0.65, 0.2], [0.4, 0.2, 0.4]]),
]
targets = [
torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 0]]),
torch.tensor([[0, 1, 0], [0, 1, 0], [0, 1, 0]]),
]
# Second update's expected value
expected_value = {"top_1": 2 / 3.0, "top_2": 2 / 6.0}
self.meter_get_set_classy_state_test(
meters, model_outputs, targets, expected_value
)
def test_meter_distributed(self):
# Meter0 will execute on one process, Meter1 on the other
meters = [PrecisionAtKMeter(topk=[1, 2]), PrecisionAtKMeter(topk=[1, 2])]
# Batchsize = 3, num classes = 3, score is probability of class
model_outputs = [
torch.tensor(
[[0.3, 0.4, 0.3], [0.2, 0.65, 0.15], [0.33, 0.33, 0.34]]
), # Meter 0
torch.tensor(
[[0.05, 0.4, 0.05], [0.15, 0.65, 0.2], [0.4, 0.2, 0.4]]
), # Meter 1
torch.tensor(
[[0.3, 0.4, 0.3], [0.2, 0.65, 0.15], [0.33, 0.33, 0.34]]
), # Meter 0
torch.tensor(
[[0.05, 0.4, 0.05], [0.15, 0.65, 0.2], [0.4, 0.2, 0.4]]
), # Meter 1
]
# Class 0 is the correct class for sample 1, class 2 for sample 2, etc
targets = [
torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]]), # Meter 0
torch.tensor([[0, 1, 0], [0, 1, 0], [0, 1, 0]]), # Meter 1
torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]]), # Meter 0
torch.tensor([[0, 1, 0], [0, 1, 0], [0, 1, 0]]), # Meter 1
]
# In first two updates there are 4 correct top-1, 6 correct in top 2
# The same occurs in the second two updates and is added to first
expected_values = [
{"top_1": 4 / 6.0, "top_2": 6 / 12.0}, # After one update to each meter
{"top_1": 8 / 12.0, "top_2": 12 / 24.0}, # After two updates to each meter
]
self.meter_distributed_test(meters, model_outputs, targets, expected_values)
def test_non_onehot_target(self):
"""
This test verifies that the meter works as expected on a single
update + reset + same single update.
"""
meter = PrecisionAtKMeter(topk=[1, 2])
# Batchsize = 2, num classes = 3, score is probability of class
model_outputs = [
torch.tensor([[0.05, 0.4, 0.05], [0.15, 0.65, 0.2], [0.4, 0.2, 0.4]]),
torch.tensor([[0.2, 0.4, 0.4], [0.2, 0.65, 0.15], [0.1, 0.8, 0.1]]),
]
# One-hot encoding, 1 = positive for class
targets = [
torch.tensor([[1], [1], [1]]), # [[0, 1, 0], [0, 1, 0], [0, 1, 0]]
torch.tensor([[0], [1], [2]]), # [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
]
# Note for ties, we select randomly, so we should not use ambiguous ties
# First batch has top-1 precision of 2/3.0, top-2 precision of 2/6.0
# Second batch has top-1 precision of 1/3.0, top-2 precision of 1/6.0
expected_value = {"top_1": 3 / 6.0, "top_2": 3 / 12.0}
self.meter_update_and_reset_test(meter, model_outputs, targets, expected_value)
def test_non_onehot_target_one_dim_target(self):
"""
This test verifies that the meter works as expected on a single
update + reset + same single update with one dimensional targets.
"""
meter = PrecisionAtKMeter(topk=[1, 2])
# Batchsize = 2, num classes = 3, score is probability of class
model_outputs = [
torch.tensor([[0.05, 0.4, 0.05], [0.15, 0.65, 0.2], [0.4, 0.2, 0.4]]),
torch.tensor([[0.2, 0.4, 0.4], [0.2, 0.65, 0.15], [0.1, 0.8, 0.1]]),
]
# One-hot encoding, 1 = positive for class
targets = [
torch.tensor([1, 1, 1]), # [[0, 1, 0], [0, 1, 0], [0, 1, 0]]
torch.tensor([0, 1, 2]), # [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
]
# Note for ties, we select randomly, so we should not use ambiguous ties
# First batch has top-1 precision of 2/3.0, top-2 precision of 2/6.0
# Second batch has top-1 precision of 1/3.0, top-2 precision of 1/6.0
expected_value = {"top_1": 3 / 6.0, "top_2": 3 / 12.0}
self.meter_update_and_reset_test(meter, model_outputs, targets, expected_value)
def test_meter_fp16(self):
"""
This test verifies that the meter works if the input tensor is fp16.
"""
meter = PrecisionAtKMeter(topk=[1, 2])
# Batchsize = 3, num classes = 3, score is probability of class
model_output = torch.tensor(
[
[0.2, 0.4, 0.4], # top-1: 1/2, top-2: 1/2
[0.2, 0.65, 0.15], # top-1: 1, top-2: 1/0
[0.33, 0.33, 0.34], # top-1: 2, top-2: 2/0?1
]
).half()
# One-hot encoding, 1 = positive for class
# sample-1: 1, sample-2: 0, sample-3: 0,1,2
target = torch.tensor([[0, 1, 0], [1, 0, 0], [1, 1, 1]]).half()
# Note for ties, we select randomly, so we should not use ambiguous ties
expected_value = {"top_1": 2 / 3.0, "top_2": 4 / 6.0}
self.meter_update_and_reset_test(meter, model_output, target, expected_value)
|
ClassyVision-main
|
test/meters_precision_meter_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from classy_vision.optim.param_scheduler import (
build_param_scheduler,
ConstantParamScheduler,
)
class TestFixedScheduler(unittest.TestCase):
_num_epochs = 12
def _get_valid_config(self):
return {"name": "constant", "num_epochs": self._num_epochs, "value": 0.1}
def test_invalid_config(self):
# Invalid num epochs
config = self._get_valid_config()
bad_config = copy.deepcopy(config)
del bad_config["value"]
with self.assertRaises((AssertionError, TypeError)):
ConstantParamScheduler.from_config(bad_config)
def test_scheduler(self):
config = self._get_valid_config()
scheduler = ConstantParamScheduler.from_config(config)
schedule = [
scheduler(epoch_num / self._num_epochs)
for epoch_num in range(self._num_epochs)
]
expected_schedule = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
self.assertEqual(schedule, expected_schedule)
# The input for the scheduler should be in the interval [0;1), open
with self.assertRaises(RuntimeError):
scheduler(1)
def test_build_constant_scheduler(self):
config = self._get_valid_config()
scheduler = build_param_scheduler(config)
self.assertTrue(isinstance(scheduler, ConstantParamScheduler))
|
ClassyVision-main
|
test/optim_param_scheduler_constant_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import shutil
import tempfile
import unittest
import torch
from classy_vision.dataset.transforms import ClassyTransform
from classy_vision.hub import ClassyHubInterface
from classy_vision.models import build_model, ClassyModel
from classy_vision.tasks import build_task, ClassyTask
from test.generic.config_utils import get_test_task_config
from torchvision import models, transforms
class TestTransform(ClassyTransform):
def __call__(self, x):
return x
class TestClassyHubInterface(unittest.TestCase):
def setUp(self):
# create a base directory to write image files to
self.base_dir = tempfile.mkdtemp()
self.image_path = self.base_dir + "/img.jpg"
# create an image with a non standard size
image_tensor = torch.zeros((3, 1000, 2500), dtype=torch.float)
transforms.ToPILImage()(image_tensor).save(self.image_path)
def tearDown(self):
# delete all the temporary data created
shutil.rmtree(self.base_dir)
def _test_predict_and_extract_features(self, hub_interface: ClassyHubInterface):
dataset = hub_interface.create_image_dataset(
image_files=[self.image_path], phase_type="test"
)
data_iterator = hub_interface.get_data_iterator(dataset)
input = next(data_iterator)
# set the model to eval mode
hub_interface.eval()
output = hub_interface.predict(input)
self.assertIsNotNone(output)
# see the prediction for the input
hub_interface.predict(input).argmax().item()
# check extract features
output = hub_interface.extract_features(input)
self.assertIsNotNone(output)
def _get_classy_model(self):
config = get_test_task_config()
model_config = config["model"]
return build_model(model_config)
def _get_non_classy_model(self):
return models.resnet18(pretrained=False)
def test_from_task(self):
config = get_test_task_config()
task = build_task(config)
hub_interface = ClassyHubInterface.from_task(task)
self.assertIsInstance(hub_interface.task, ClassyTask)
self.assertIsInstance(hub_interface.model, ClassyModel)
# this will pick up the transform from the task's config
self._test_predict_and_extract_features(hub_interface)
# test that the correct transform is picked up
phase_type = "test"
test_transform = TestTransform()
task.datasets[phase_type].transform = test_transform
hub_interface = ClassyHubInterface.from_task(task)
dataset = hub_interface.create_image_dataset(
image_files=[self.image_path], phase_type=phase_type
)
self.assertIsInstance(dataset.transform, TestTransform)
def test_from_model(self):
for model in [self._get_classy_model(), self._get_non_classy_model()]:
hub_interface = ClassyHubInterface.from_model(model)
self.assertIsNone(hub_interface.task)
self.assertIsInstance(hub_interface.model, ClassyModel)
# this will pick up the transform from imagenet
self._test_predict_and_extract_features(hub_interface)
|
ClassyVision-main
|
test/hub_classy_hub_interface_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import os
import shutil
import tempfile
import torch
from classy_vision.hooks import TorchscriptHook
from classy_vision.models import ResNet
from classy_vision.tasks import build_task
from test.generic.config_utils import get_test_task_config
from test.generic.hook_test_utils import HookTestBase
TORCHSCRIPT_FILE = "torchscript.pt"
class TestTorchscriptHook(HookTestBase):
def setUp(self) -> None:
self.base_dir = tempfile.mkdtemp()
self.orig_wrapper_cls = ResNet.wrapper_cls
def tearDown(self) -> None:
shutil.rmtree(self.base_dir)
ResNet.wrapper_cls = self.orig_wrapper_cls
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {"torchscript_folder": "/test/"}
invalid_config = copy.deepcopy(config)
invalid_config["torchscript_folder"] = 12
self.constructor_test_helper(
config=config,
hook_type=TorchscriptHook,
hook_registry_name="torchscript",
invalid_configs=[invalid_config],
)
def execute_hook(self, config, torchscript_folder, torchscript_hook) -> None:
task = build_task(config)
task.prepare()
# create checkpoint dir, verify on_start hook runs
os.mkdir(torchscript_folder)
torchscript_hook.on_start(task)
task.train = True
# call the on end function
torchscript_hook.on_end(task)
# load torchscript file
torchscript_file_name = (
f"{torchscript_hook.torchscript_folder}/{TORCHSCRIPT_FILE}"
)
torchscript = torch.jit.load(torchscript_file_name)
# compare model load from checkpoint vs torchscript
with torch.no_grad():
batchsize = 1
model = task.model
input_data = torch.randn(
(batchsize,) + model.input_shape, dtype=torch.float
)
if torch.cuda.is_available():
input_data = input_data.cuda()
model = model.cuda()
torchscript = torchscript.cuda()
checkpoint_out = model(input_data)
torchscript_out = torchscript(input_data)
self.assertTrue(torch.allclose(checkpoint_out, torchscript_out, atol=1e-5))
def test_torchscripting_using_trace(self):
"""
Test that the save_torchscript function works as expected with trace
"""
config = get_test_task_config()
torchscript_folder = self.base_dir + "/torchscript_end_test/"
# create a torchscript hook using trace
torchscript_hook = TorchscriptHook(torchscript_folder)
self.execute_hook(config, torchscript_folder, torchscript_hook)
def test_torchscripting_using_script(self):
"""
Test that the save_torchscript function works as expected with script
"""
config = get_test_task_config()
# Setting wrapper_cls to None to make ResNet model torchscriptable
ResNet.wrapper_cls = None
torchscript_folder = self.base_dir + "/torchscript_end_test/"
# create a torchscript hook using script
torchscript_hook = TorchscriptHook(torchscript_folder, use_trace=False)
self.execute_hook(config, torchscript_folder, torchscript_hook)
|
ClassyVision-main
|
test/hooks_torchscript_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import os
import shutil
import tempfile
import unittest
import torch
import torch.nn as nn
from classy_vision.generic.util import load_checkpoint
from classy_vision.heads import FullyConnectedHead, IdentityHead
from classy_vision.hooks import CheckpointHook
from classy_vision.models import (
build_model,
ClassyModel,
ClassyModelWrapper,
register_model,
)
from classy_vision.models.classy_model import _ClassyModelAdapter
from classy_vision.tasks import build_task
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_fast_test_task_config, get_test_task_config
from torchvision import models
@register_model("my_test_model")
class MyTestModel(ClassyModel):
def __init__(self):
super().__init__()
self.linear = nn.Linear(10, 5)
self.linear2 = nn.Linear(5, 10)
def forward(self, x):
return self.linear2(self.linear(x))
@classmethod
def from_config(cls, config):
return cls()
class MyTestModel2(ClassyModel):
def forward(self, x):
return x + 1
# need to define these properties to make the model torchscriptable
@property
def input_shape(self):
return (1, 2, 3)
class TestSimpleClassyModelWrapper(ClassyModelWrapper):
def forward(self, x):
return self.classy_model(x) * 2
class TestClassyModel(unittest.TestCase):
def setUp(self) -> None:
self.base_dir = tempfile.mkdtemp()
self.orig_wrapper_cls_1 = MyTestModel.wrapper_cls
self.orig_wrapper_cls_2 = MyTestModel2.wrapper_cls
def tearDown(self) -> None:
shutil.rmtree(self.base_dir)
MyTestModel.wrapper_cls = self.orig_wrapper_cls_1
MyTestModel2.wrapper_cls = self.orig_wrapper_cls_2
def get_model_config(self, use_head):
config = {"name": "my_test_model"}
if use_head:
config["heads"] = [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 3,
"fork_block": "linear",
"in_plane": 5,
}
]
return config
def test_model_bad_name(self):
config = self.get_model_config(use_head=True)
test_bad_name = "__test_bad_name__"
config["name"] = test_bad_name
try:
_ = build_model(config)
except AssertionError as e:
self.assertTrue(
test_bad_name in str(e),
f"expected {test_bad_name} in error message, got {str(e)}",
)
return
self.assertTrue(False, "expected an AssertionError to be thrown")
def test_from_checkpoint(self):
config = get_test_task_config()
for use_head in [True, False]:
config["model"] = self.get_model_config(use_head)
task = build_task(config)
task.prepare()
checkpoint_folder = f"{self.base_dir}/{use_head}/"
input_args = {"config": config}
# Simulate training by setting the model parameters to zero
for param in task.model.parameters():
param.data.zero_()
checkpoint_hook = CheckpointHook(
checkpoint_folder, input_args, phase_types=["train"]
)
# Create checkpoint dir, save checkpoint
os.mkdir(checkpoint_folder)
checkpoint_hook.on_start(task)
task.train = True
checkpoint_hook.on_phase_end(task)
# Model should be checkpointed. load and compare
checkpoint = load_checkpoint(checkpoint_folder)
model = ClassyModel.from_checkpoint(checkpoint)
self.assertTrue(isinstance(model, MyTestModel))
# All parameters must be zero
for param in model.parameters():
self.assertTrue(torch.all(param.data == 0))
def test_classy_model_wrapper_instance(self):
# Test that we return a ClassyModel without a wrapper_cls
MyTestModel.wrapper_cls = None
model = MyTestModel()
self.assertEqual(type(model), MyTestModel)
self.assertIsInstance(model, MyTestModel)
self.assertIsInstance(model, ClassyModel)
self.assertIsInstance(model, nn.Module)
# Test that we return a ClassyModelWrapper when specified as the wrapper_cls
# The object should still pass the insinstance check
MyTestModel.wrapper_cls = ClassyModelWrapper
model = MyTestModel()
self.assertEqual(type(model), ClassyModelWrapper)
self.assertIsInstance(model, MyTestModel)
self.assertIsInstance(model, ClassyModel)
self.assertIsInstance(model, nn.Module)
def test_classy_model_wrapper_torch_scriptable(self):
input = torch.ones((2, 2))
for wrapper_cls, expected_output in [
(None, input + 1),
# this isn't supported yet
# (TestSimpleClassyModelWrapper, (input + 1) * 2),
]:
MyTestModel2.wrapper_cls = wrapper_cls
model = MyTestModel2()
scripted_model = torch.jit.script(model)
self.assertTrue(torch.allclose(expected_output, model(input)))
self.assertTrue(torch.allclose(expected_output, scripted_model(input)))
def test_classy_model_wrapper_torch_jittable(self):
input = torch.ones((2, 2))
for wrapper_cls, expected_output in [
(None, input + 1),
(TestSimpleClassyModelWrapper, (input + 1) * 2),
]:
MyTestModel2.wrapper_cls = wrapper_cls
model = MyTestModel2()
jitted_model = torch.jit.trace(model, input)
self.assertTrue(torch.allclose(expected_output, model(input)))
self.assertTrue(torch.allclose(expected_output, jitted_model(input)))
def test_classy_model_wrapper_attr(self):
model = MyTestModel2()
model.test_attr = 123
model_wrapper = ClassyModelWrapper(model)
self.assertTrue(hasattr(model_wrapper, "test_attr"))
self.assertEqual(model_wrapper.test_attr, 123)
# delete the attr
delattr(model_wrapper, "test_attr")
self.assertFalse(hasattr(model_wrapper, "test_attr"))
self.assertFalse(hasattr(model, "test_attr"))
def test_classy_model_set_state_strict(self):
model_1 = build_model(self.get_model_config(use_head=True))
model_state_1 = model_1.get_classy_state(deep_copy=True)
model_2 = build_model(self.get_model_config(use_head=False))
model_2.set_heads({"linear": [IdentityHead("default_head")]})
with self.assertRaises(RuntimeError):
model_2.set_classy_state(model_state_1)
model_2.set_classy_state(model_state_1, strict=False)
class TestModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(10, 5)
def forward(self, x):
return self.linear(x)
def extract_features(self, x):
return torch.cat([x, x], dim=1)
class TestClassyModelAdapter(unittest.TestCase):
def test_classy_model_adapter(self):
model = TestModel()
classy_model = ClassyModel.from_model(model)
# test that the returned object is an instance of ClassyModel
self.assertIsInstance(classy_model, ClassyModel)
# test that the returned object is also an instance of _ClassyModelAdapter
self.assertIsInstance(classy_model, _ClassyModelAdapter)
# test that forward works correctly
input = torch.zeros((100, 10))
output = classy_model(input)
self.assertEqual(output.shape, (100, 5))
# test that extract_features works correctly
input = torch.zeros((100, 10))
output = classy_model.extract_features(input)
self.assertEqual(output.shape, (100, 20))
# test that get_classy_state and set_classy_state work
nn.init.constant_(classy_model.model.linear.weight, 1)
weights = copy.deepcopy(classy_model.model.linear.weight.data)
state_dict = classy_model.get_classy_state(deep_copy=True)
nn.init.constant_(classy_model.model.linear.weight, 0)
classy_model.set_classy_state(state_dict)
self.assertTrue(torch.allclose(weights, classy_model.model.linear.weight.data))
def test_classy_model_adapter_properties(self):
# test that the properties work correctly when passed to the adapter
model = TestModel()
input_shape = (10,)
model_depth = 1
classy_model = ClassyModel.from_model(
model, input_shape=input_shape, model_depth=model_depth
)
self.assertEqual(classy_model.input_shape, input_shape)
def test_train_step(self):
# test that the model can be run in a train step
model = models.resnet34(pretrained=False)
classy_model = ClassyModel.from_model(model)
config = get_fast_test_task_config()
task = build_task(config)
task.set_model(classy_model)
trainer = LocalTrainer()
trainer.train(task)
def test_heads(self):
model = models.resnet50(pretrained=False)
classy_model = ClassyModel.from_model(model)
num_classes = 5
head = FullyConnectedHead(
unique_id="default", in_plane=2048, num_classes=num_classes
)
classy_model.set_heads({"layer4": [head]})
input = torch.ones((1, 3, 224, 224))
self.assertEqual(classy_model(input).shape, (1, num_classes))
|
ClassyVision-main
|
test/models_classy_model_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import json
import os
import subprocess
import tempfile
import unittest
from pathlib import Path
import torch
from test.generic.config_utils import (
get_distributed_launch_cmd,
get_test_mlp_task_config,
)
class TestDistributedTrainer(unittest.TestCase):
def setUp(self):
config = get_test_mlp_task_config()
invalid_config = copy.deepcopy(config)
invalid_config["name"] = "invalid_task"
sync_bn_config = copy.deepcopy(config)
sync_bn_config["batch_norm_sync_mode"] = "pytorch"
self.config_files = {}
for config_key, config in [
("config", config),
("invalid_config", invalid_config),
("sync_bn_config", sync_bn_config),
]:
with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
json.dump(config, f)
f.flush()
self.config_files[config_key] = f.name
self.path = Path(__file__).parent.absolute()
def tearDown(self):
for config_file in self.config_files.values():
os.unlink(config_file)
def test_training(self):
"""Checks we can train a small MLP model."""
num_processes = 2
for config_key, expected_success in [
("invalid_config", False),
("config", True),
]:
cmd = get_distributed_launch_cmd(
num_processes=num_processes,
trainer_path=f"{self.path}/../classy_train.py",
config_path=self.config_files[config_key],
)
result = subprocess.run(cmd, shell=True)
success = result.returncode == 0
self.assertEqual(success, expected_success)
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_sync_batch_norm(self):
"""Test that sync batch norm training doesn't hang."""
num_processes = 2
cmd = get_distributed_launch_cmd(
num_processes=num_processes,
trainer_path=f"{self.path}/../classy_train.py",
config_path=self.config_files["sync_bn_config"],
)
result = subprocess.run(cmd, shell=True)
self.assertEqual(result.returncode, 0)
|
ClassyVision-main
|
test/trainer_distributed_trainer_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from classy_vision.dataset.transforms.mixup import MixupTransform
class DatasetTransformsMixupTest(unittest.TestCase):
def test_mixup_transform_single_label_image_batch(self):
mixup_alpha = 2.0
num_classes = 3
for mode in ["batch", "pair", "elem"]:
mixup_transform = MixupTransform(mixup_alpha, num_classes, mode=mode)
sample = {
"input": torch.rand(4, 3, 224, 224, dtype=torch.float32),
"target": torch.as_tensor([0, 1, 2, 2], dtype=torch.int32),
}
sample_mixup = mixup_transform(sample)
self.assertTrue(sample["input"].shape == sample_mixup["input"].shape)
self.assertTrue(sample_mixup["target"].shape[0] == 4)
self.assertTrue(sample_mixup["target"].shape[1] == 3)
def test_cutmix_transform_single_label_image_batch(self):
mixup_alpha = 0
cutmix_alpha = 0.2
num_classes = 3
for mode in ["batch", "pair", "elem"]:
for minmax in [None, (0.3, 0.7)]:
cutmix_transform = MixupTransform(
mixup_alpha,
num_classes,
cutmix_alpha=cutmix_alpha,
mode=mode,
cutmix_minmax=minmax,
)
sample = {
"input": torch.rand(4, 3, 224, 224, dtype=torch.float32),
"target": torch.as_tensor([0, 1, 2, 2], dtype=torch.int32),
}
sample_cutmix = cutmix_transform(sample)
self.assertTrue(sample["input"].shape == sample_cutmix["input"].shape)
self.assertTrue(sample_cutmix["target"].shape[0] == 4)
self.assertTrue(sample_cutmix["target"].shape[1] == 3)
def test_mixup_cutmix_transform_single_label_image_batch(self):
mixup_alpha = 0.3
cutmix_alpha = 0.2
num_classes = 3
for mode in ["batch", "pair", "elem"]:
cutmix_transform = MixupTransform(
mixup_alpha,
num_classes,
cutmix_alpha=cutmix_alpha,
switch_prob=0.5,
mode=mode,
)
for _i in range(4):
sample = {
"input": torch.rand(4, 3, 224, 224, dtype=torch.float32),
"target": torch.as_tensor([0, 1, 2, 2], dtype=torch.int32),
}
sample_cutmix = cutmix_transform(sample)
self.assertTrue(sample["input"].shape == sample_cutmix["input"].shape)
self.assertTrue(sample_cutmix["target"].shape[0] == 4)
self.assertTrue(sample_cutmix["target"].shape[1] == 3)
def test_mixup_cutmix_transform_single_label_image_batch_label_smooth(self):
mixup_alpha = 0.3
cutmix_alpha = 0.2
num_classes = 3
for mode in ["batch", "pair", "elem"]:
cutmix_transform = MixupTransform(
mixup_alpha,
num_classes,
cutmix_alpha=cutmix_alpha,
switch_prob=0.5,
mode=mode,
label_smoothing=0.1,
)
for _i in range(4):
sample = {
"input": torch.rand(4, 3, 224, 224, dtype=torch.float32),
"target": torch.as_tensor([0, 1, 2, 2], dtype=torch.int32),
}
sample_cutmix = cutmix_transform(sample)
self.assertTrue(sample["input"].shape == sample_cutmix["input"].shape)
self.assertTrue(sample_cutmix["target"].shape[0] == 4)
self.assertTrue(sample_cutmix["target"].shape[1] == 3)
def test_mixup_transform_single_label_image_batch_missing_num_classes(self):
mixup_alpha = 2.0
mixup_transform = MixupTransform(mixup_alpha, None)
sample = {
"input": torch.rand(4, 3, 224, 224, dtype=torch.float32),
"target": torch.as_tensor([0, 1, 2, 2], dtype=torch.int32),
}
with self.assertRaises(Exception):
mixup_transform(sample)
def test_mixup_transform_multi_label_image_batch(self):
mixup_alpha = 2.0
mixup_transform = MixupTransform(mixup_alpha, None)
sample = {
"input": torch.rand(4, 3, 224, 224, dtype=torch.float32),
"target": torch.as_tensor(
[[1, 0, 0, 0], [0, 1, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1]],
dtype=torch.int32,
),
}
sample_mixup = mixup_transform(sample)
self.assertTrue(sample["input"].shape == sample_mixup["input"].shape)
self.assertTrue(sample["target"].shape == sample_mixup["target"].shape)
def test_mixup_transform_single_label_multi_modal_batch(self):
mixup_alpha = 2.0
num_classes = 3
mixup_transform = MixupTransform(mixup_alpha, num_classes)
sample = {
"input": {
"video": torch.rand(4, 3, 4, 224, 224, dtype=torch.float32),
"audio": torch.rand(4, 1, 40, 100, dtype=torch.float32),
},
"target": torch.as_tensor([0, 1, 2, 2], dtype=torch.int32),
}
mixup_transform(sample)
def test_mixup_transform_multi_label_multi_modal_batch(self):
mixup_alpha = 2.0
mixup_transform = MixupTransform(mixup_alpha, None)
sample = {
"input": {
"video": torch.rand(4, 3, 4, 224, 224, dtype=torch.float32),
"audio": torch.rand(4, 1, 40, 100, dtype=torch.float32),
},
"target": torch.as_tensor(
[[1, 0, 0, 0], [0, 1, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1]],
dtype=torch.int32,
),
}
mixup_transform(sample)
|
ClassyVision-main
|
test/dataset_transforms_mixup_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import torch
from classy_vision.losses import build_loss, ClassyLoss, register_loss, SumArbitraryLoss
@register_loss("mock_a")
class MockLoss1(ClassyLoss):
def forward(self, pred, target):
return torch.tensor(1.0)
@classmethod
def from_config(cls, config):
return cls()
@register_loss("mock_b")
class MockLoss2(ClassyLoss):
def forward(self, pred, target):
return torch.tensor(2.0)
@classmethod
def from_config(cls, config):
return cls()
@register_loss("mock_c")
class MockLoss3(ClassyLoss):
def forward(self, pred, target):
return torch.tensor(3.0)
@classmethod
def from_config(cls, config):
return cls()
class TestSumArbitraryLoss(unittest.TestCase):
def _get_config(self):
return {
"name": "sum_arbitrary",
"weights": [1.0, 1.0, 1.0],
"losses": [{"name": "mock_a"}, {"name": "mock_b"}, {"name": "mock_c"}],
}
def _get_outputs(self):
return torch.tensor([[2.0, 8.0]])
def _get_targets(self):
return torch.tensor([1])
def test_build_sum_arbitrary(self):
config = self._get_config()
crit = build_loss(config)
self.assertTrue(isinstance(crit, SumArbitraryLoss))
self.assertAlmostEqual(crit.weights, [1.0, 1.0, 1.0])
mod_list = [MockLoss1, MockLoss2, MockLoss3]
for idx, crit_type in enumerate(mod_list):
self.assertTrue(isinstance(crit.losses[idx], crit_type))
def test_sum_arbitrary(self):
config = self._get_config()
crit = SumArbitraryLoss.from_config(config)
outputs = self._get_outputs()
targets = self._get_targets()
self.assertAlmostEqual(crit(outputs, targets).item(), 1.0 + 2.0 + 3.0)
# Verify changing losses works
new_config = copy.deepcopy(config)
new_config.update(
{"losses": [{"name": "mock_a"}, {"name": "mock_b"}], "weights": [1.0, 1.0]}
)
crit = SumArbitraryLoss.from_config(new_config)
self.assertAlmostEqual(crit(outputs, targets).item(), 1.0 + 2.0)
# Verify changing weights works
new_config = copy.deepcopy(config)
new_config.update({"weights": [1.0, 2.0, 3.0]})
crit = SumArbitraryLoss.from_config(new_config)
self.assertAlmostEqual(
crit(outputs, targets).item(), 1.0 + 2.0 * 2.0 + 3.0 * 3.0
)
def test_deep_copy(self):
config = self._get_config()
crit1 = build_loss(config)
self.assertTrue(isinstance(crit1, SumArbitraryLoss))
outputs = self._get_outputs()
targets = self._get_targets()
crit1(outputs, targets)
crit2 = copy.deepcopy(crit1)
self.assertAlmostEqual(
crit1(outputs, targets).item(), crit2(outputs, targets).item()
)
|
ClassyVision-main
|
test/losses_sum_arbitrary_loss_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
from collections import defaultdict
import torch
from classy_vision.heads import build_head
from classy_vision.models import build_model, ClassyModel
from test.generic.config_utils import get_test_model_configs
from test.generic.utils import compare_model_state
class TestClassyModel(unittest.TestCase):
model_configs = get_test_model_configs()
def _get_config(self, model_config):
return {
"name": "classification_task",
"num_epochs": 12,
"loss": {"name": "test_loss"},
"dataset": {
"name": "imagenet",
"batchsize_per_replica": 8,
"use_pairs": False,
"num_samples_per_phase": None,
"use_shuffle": {"train": True, "test": False},
},
"meters": [],
"model": model_config,
"optimizer": {"name": "test_opt"},
}
def _compare_model_state(self, state, state2):
compare_model_state(self, state, state2)
def test_build_model(self):
for cfg in self.model_configs:
config = self._get_config(cfg)
model = build_model(config["model"])
self.assertTrue(isinstance(model, ClassyModel))
self.assertTrue(
type(model.input_shape) == tuple and len(model.input_shape) == 3
)
def test_get_set_state(self):
config = self._get_config(self.model_configs[0])
model = build_model(config["model"])
fake_input = torch.Tensor(1, 3, 224, 224).float()
model.eval()
state = model.get_classy_state()
with torch.no_grad():
output = model(fake_input)
model2 = build_model(config["model"])
model2.set_classy_state(state)
# compare the states
state2 = model2.get_classy_state()
self._compare_model_state(state, state2)
model2.eval()
with torch.no_grad():
output2 = model2(fake_input)
self.assertTrue(torch.allclose(output, output2))
# test deep_copy by assigning a deep copied state to model2
# and then changing the original model's state
state = model.get_classy_state(deep_copy=True)
model3 = build_model(config["model"])
state3 = model3.get_classy_state()
# assign model2's state to model's and also re-assign model's state
model2.set_classy_state(state)
model.set_classy_state(state3)
# compare the states
state2 = model2.get_classy_state()
self._compare_model_state(state, state2)
def test_get_set_head_states(self):
config = copy.deepcopy(self._get_config(self.model_configs[0]))
head_configs = config["model"]["heads"]
config["model"]["heads"] = []
model = build_model(config["model"])
trunk_state = model.get_classy_state()
heads = defaultdict(list)
for head_config in head_configs:
head = build_head(head_config)
heads[head_config["fork_block"]].append(head)
model.set_heads(heads)
model_state = model.get_classy_state()
# the heads should be the same as we set
self.assertEqual(len(heads), len(model.get_heads()))
for block_name, hs in model.get_heads().items():
self.assertEqual(hs, heads[block_name])
model.clear_heads()
self._compare_model_state(model.get_classy_state(), trunk_state)
model.set_heads(heads)
self._compare_model_state(model.get_classy_state(), model_state)
|
ClassyVision-main
|
test/manual/models_classy_vision_model_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.optim.adamw_mt import AdamWMT
from test.generic.optim_test_util import TestOptimizer
class TestAdamWMTOptimizer(TestOptimizer, unittest.TestCase):
def _check_momentum_buffer(self):
return False
def _get_config(self):
return {
"name": "adamw_mt",
"num_epochs": 90,
"lr": 0.1,
"betas": (0.9, 0.99),
"eps": 1e-8,
"weight_decay": 0.0001,
"amsgrad": False,
}
def _instance_to_test(self):
return AdamWMT
|
ClassyVision-main
|
test/manual/optim_adamw_mt_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import unittest.mock as mock
import progressbar
from classy_vision.hooks import ProgressBarHook
from test.generic.config_utils import get_test_classy_task
from test.generic.hook_test_utils import HookTestBase
class TestProgressBarHook(HookTestBase):
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {}
self.constructor_test_helper(
config=config, hook_type=ProgressBarHook, hook_registry_name="progress_bar"
)
@mock.patch("classy_vision.hooks.progress_bar_hook.progressbar")
@mock.patch("classy_vision.hooks.progress_bar_hook.is_primary")
def test_progress_bar(
self, mock_is_primary: mock.MagicMock, mock_progressbar_pkg: mock.MagicMock
) -> None:
"""
Tests that the progress bar is created, updated and destroyed correctly.
"""
mock_progress_bar = mock.create_autospec(progressbar.ProgressBar, instance=True)
mock_progressbar_pkg.ProgressBar.return_value = mock_progress_bar
mock_is_primary.return_value = True
task = get_test_classy_task()
task.prepare()
task.advance_phase()
num_batches = task.num_batches_per_phase
# make sure we are checking at least one batch
self.assertGreater(num_batches, 0)
# create a progress bar hook
progress_bar_hook = ProgressBarHook()
# progressbar.ProgressBar should be init-ed with num_batches
progress_bar_hook.on_phase_start(task)
mock_progressbar_pkg.ProgressBar.assert_called_once_with(num_batches)
mock_progress_bar.start.assert_called_once_with()
mock_progress_bar.start.reset_mock()
mock_progressbar_pkg.ProgressBar.reset_mock()
# on_step should update the progress bar correctly
for i in range(num_batches):
progress_bar_hook.on_step(task)
mock_progress_bar.update.assert_called_once_with(i + 1)
mock_progress_bar.update.reset_mock()
# check that even if on_step is called again, the progress bar is
# only updated with num_batches
for _ in range(num_batches):
progress_bar_hook.on_step(task)
mock_progress_bar.update.assert_called_once_with(num_batches)
mock_progress_bar.update.reset_mock()
# finish should be called on the progress bar
progress_bar_hook.on_phase_end(task)
mock_progress_bar.finish.assert_called_once_with()
mock_progress_bar.finish.reset_mock()
# check that even if the progress bar isn't created, the code doesn't
# crash
progress_bar_hook = ProgressBarHook()
try:
progress_bar_hook.on_step(task)
progress_bar_hook.on_phase_end(task)
except Exception as e:
self.fail(
"Received Exception when on_phase_start() isn't called: {}".format(e)
)
mock_progressbar_pkg.ProgressBar.assert_not_called()
# check that a progress bar is not created if is_primary() returns False
mock_is_primary.return_value = False
progress_bar_hook = ProgressBarHook()
try:
progress_bar_hook.on_phase_start(task)
progress_bar_hook.on_step(task)
progress_bar_hook.on_phase_end(task)
except Exception as e:
self.fail("Received Exception when is_primary() is False: {}".format(e))
self.assertIsNone(progress_bar_hook.progress_bar)
mock_progressbar_pkg.ProgressBar.assert_not_called()
|
ClassyVision-main
|
test/manual/hooks_progress_bar_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import torch
from classy_vision.tasks import build_task, ClassificationTask
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_fast_test_task_config, get_test_task_config
class TestClassificationTaskAMP(unittest.TestCase):
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_build_task(self):
config = get_test_task_config()
task = build_task(config)
self.assertTrue(isinstance(task, ClassificationTask))
# check that AMP is disabled by default
self.assertIsNone(task.amp_args)
# test a valid APEX AMP opt level
config = copy.deepcopy(config)
config["amp_args"] = {"opt_level": "O1"}
task = build_task(config)
self.assertTrue(isinstance(task, ClassificationTask))
# test a valid Pytorch AMP
config = copy.deepcopy(config)
config["amp_args"] = {"amp_type": "pytorch"}
task = build_task(config)
self.assertTrue(isinstance(task, ClassificationTask))
@unittest.skipUnless(torch.cuda.is_available(), "This test needs a gpu to run")
def test_training(self):
# Test an Apex AMP training
config = get_fast_test_task_config()
config["amp_args"] = {"opt_level": "O2"}
task = build_task(config)
task.set_use_gpu(True)
trainer = LocalTrainer()
trainer.train(task)
# Test a Pytorch AMP training
config["amp_args"] = {"amp_type": "pytorch"}
task = build_task(config)
task.set_use_gpu(True)
trainer = LocalTrainer()
trainer.train(task)
|
ClassyVision-main
|
test/manual/tasks_classification_task_amp_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.hooks import ModelComplexityHook
from classy_vision.models import build_model
from test.generic.config_utils import get_test_classy_task, get_test_model_configs
from test.generic.hook_test_utils import HookTestBase
class TestModelComplexityHook(HookTestBase):
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {}
self.constructor_test_helper(
config=config,
hook_type=ModelComplexityHook,
hook_registry_name="model_complexity",
)
def test_model_complexity_hook(self) -> None:
model_configs = get_test_model_configs()
task = get_test_classy_task()
task.prepare()
# create a model complexity hook
model_complexity_hook = ModelComplexityHook()
for model_config in model_configs:
model = build_model(model_config)
task.base_model = model
with self.assertLogs():
model_complexity_hook.on_start(task)
|
ClassyVision-main
|
test/manual/hooks_model_complexity_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.optim.adamw import AdamW
from test.generic.optim_test_util import TestOptimizer
class TestAdamWOptimizer(TestOptimizer, unittest.TestCase):
def _check_momentum_buffer(self):
return False
def _get_config(self):
return {
"name": "adamw",
"num_epochs": 90,
"lr": 0.1,
"betas": (0.9, 0.99),
"eps": 1e-8,
"weight_decay": 0.0001,
"amsgrad": False,
}
def _instance_to_test(self):
return AdamW
|
ClassyVision-main
|
test/manual/optim_adamw_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import unittest
import unittest.mock as mock
from itertools import product
from classy_vision.hooks import VisdomHook
from classy_vision.tasks import build_task
from test.generic.config_utils import get_test_task_config
from test.generic.hook_test_utils import HookTestBase
from visdom import Visdom
class TestVisdomHook(HookTestBase):
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {
"server": "test_server",
"port": "test_port",
"env": "test_env",
"title_suffix": "_test_suffix",
}
self.constructor_test_helper(
config=config, hook_type=VisdomHook, hook_registry_name="visdom"
)
@mock.patch("classy_vision.hooks.visdom_hook.is_primary")
@mock.patch("classy_vision.hooks.visdom_hook.Visdom", autospec=True)
def test_visdom(
self, mock_visdom_cls: mock.MagicMock, mock_is_primary: mock.MagicMock
) -> None:
"""
Tests that visdom is populated with plots.
"""
mock_visdom = mock.create_autospec(Visdom, instance=True)
mock_visdom_cls.return_value = mock_visdom
# set up the task and state
config = get_test_task_config()
config["dataset"]["train"]["batchsize_per_replica"] = 2
config["dataset"]["test"]["batchsize_per_replica"] = 5
task = build_task(config)
task.prepare()
losses = [1.2, 2.3, 1.23, 2.33]
loss_val = sum(losses) / len(losses)
task.losses = losses
visdom_server = "localhost"
visdom_port = 8097
for primary, visdom_conn in product([False, True], [False, True]):
mock_is_primary.return_value = primary
mock_visdom.check_connection.return_value = visdom_conn
# create a visdom hook
visdom_hook = VisdomHook(visdom_server, visdom_port)
mock_visdom_cls.assert_called_once()
mock_visdom_cls.reset_mock()
counts = {"train": 0, "test": 0}
count = 0
for phase_idx in range(10):
train = phase_idx % 2 == 0
task.train = train
phase_type = "train" if train else "test"
counts[phase_type] += 1
count += 1
# test that the metrics don't change if losses is empty and that
# visdom.line() is not called
task.losses = []
original_metrics = copy.deepcopy(visdom_hook.metrics)
visdom_hook.on_phase_end(task)
self.assertDictEqual(original_metrics, visdom_hook.metrics)
mock_visdom.line.assert_not_called()
# test that the metrics are updated correctly when losses
# is non empty
task.losses = [loss * count for loss in losses]
visdom_hook.on_phase_end(task)
# every meter should be present and should have the correct length
for meter in task.meters:
for key in meter.value:
key = phase_type + "_" + meter.name + "_" + key
self.assertTrue(
key in visdom_hook.metrics
and type(visdom_hook.metrics[key]) == list
and len(visdom_hook.metrics[key]) == counts[phase_type]
)
# the loss metric should be calculated correctly
loss_key = phase_type + "_loss"
self.assertTrue(
loss_key in visdom_hook.metrics
and type(visdom_hook.metrics[loss_key]) == list
and len(visdom_hook.metrics[loss_key]) == counts[phase_type]
)
self.assertAlmostEqual(
visdom_hook.metrics[loss_key][-1],
loss_val * count,
places=4,
)
# the lr metric should be correct
lr_key = phase_type + "_learning_rate"
self.assertTrue(
lr_key in visdom_hook.metrics
and type(visdom_hook.metrics[lr_key]) == list
and len(visdom_hook.metrics[lr_key]) == counts[phase_type]
)
self.assertAlmostEqual(
visdom_hook.metrics[lr_key][-1],
task.optimizer.options_view.lr,
places=4,
)
if primary and not train and visdom_conn:
# visdom.line() should be called once
mock_visdom.line.assert_called_once()
mock_visdom.line.reset_mock()
else:
# visdom.line() should not be called
mock_visdom.line.assert_not_called()
|
ClassyVision-main
|
test/manual/hooks_visdom_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import shutil
import tempfile
import unittest.mock as mock
from itertools import product
from classy_vision.hooks import TensorboardPlotHook
from classy_vision.optim.param_scheduler import ClassyParamScheduler, UpdateInterval
from classy_vision.tasks import build_task
from classy_vision.tasks.classification_task import LastBatchInfo
from classy_vision.trainer import LocalTrainer
from test.generic.config_utils import get_test_mlp_task_config, get_test_task_config
from test.generic.hook_test_utils import HookTestBase
from torch.utils.tensorboard import SummaryWriter
class TestTensorboardPlotHook(HookTestBase):
def setUp(self) -> None:
self.base_dir = tempfile.mkdtemp()
def tearDown(self) -> None:
shutil.rmtree(self.base_dir)
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {"summary_writer": {}, "log_period": 5}
invalid_config = copy.deepcopy(config)
invalid_config["log_period"] = "this is not an int"
self.constructor_test_helper(
config=config,
hook_type=TensorboardPlotHook,
hook_registry_name="tensorboard_plot",
hook_kwargs={"tb_writer": SummaryWriter(), "log_period": 5},
invalid_configs=[invalid_config],
)
@mock.patch("classy_vision.hooks.tensorboard_plot_hook.is_primary")
def test_writer(self, mock_is_primary_func: mock.MagicMock) -> None:
"""
Tests that the tensorboard writer writes the correct scalars to SummaryWriter
iff is_primary() is True.
"""
for phase_idx, primary in product([0, 1, 2], [True, False]):
train, phase_type = (
(True, "train") if phase_idx % 2 == 0 else (False, "test")
)
mock_is_primary_func.return_value = primary
# set up the task and state
config = get_test_task_config()
config["dataset"]["train"]["batchsize_per_replica"] = 2
config["dataset"]["test"]["batchsize_per_replica"] = 5
task = build_task(config)
task.prepare()
task.advance_phase()
task.phase_idx = phase_idx
task.train = train
losses = [1.23, 4.45, 12.3, 3.4]
sample_fetch_times = [1.1, 2.2, 3.3, 2.2]
summary_writer = SummaryWriter(self.base_dir)
# create a spy on top of summary_writer
summary_writer = mock.MagicMock(wraps=summary_writer)
# create a loss lr tensorboard hook
tensorboard_plot_hook = TensorboardPlotHook(summary_writer)
# run the hook in the correct order
tensorboard_plot_hook.on_phase_start(task)
# test tasks which do not pass the sample_fetch_times as well
disable_sample_fetch_times = phase_idx == 0
for loss, sample_fetch_time in zip(losses, sample_fetch_times):
task.losses.append(loss)
step_data = (
{}
if disable_sample_fetch_times
else {"sample_fetch_time": sample_fetch_time}
)
task.last_batch = LastBatchInfo(None, None, None, None, step_data)
tensorboard_plot_hook.on_step(task)
tensorboard_plot_hook.on_phase_end(task)
if primary:
# add_scalar() should have been called with the right scalars
if train:
learning_rate_key = f"Learning Rate/{phase_type}"
summary_writer.add_scalar.assert_any_call(
learning_rate_key,
mock.ANY,
global_step=mock.ANY,
walltime=mock.ANY,
)
avg_loss_key = f"Losses/{phase_type}"
summary_writer.add_scalar.assert_any_call(
avg_loss_key, mock.ANY, global_step=mock.ANY
)
for meter in task.meters:
for name in meter.value:
meter_key = f"Meters/{phase_type}/{meter.name}/{name}"
summary_writer.add_scalar.assert_any_call(
meter_key, mock.ANY, global_step=mock.ANY
)
if step_data:
summary_writer.add_scalar.assert_any_call(
f"Speed/{phase_type}/cumulative_sample_fetch_time",
mock.ANY,
global_step=mock.ANY,
walltime=mock.ANY,
)
else:
# add_scalar() shouldn't be called since is_primary() is False
summary_writer.add_scalar.assert_not_called()
summary_writer.add_scalar.reset_mock()
def test_logged_lr(self):
# Mock LR scheduler
class SchedulerMock(ClassyParamScheduler):
def __call__(self, where):
return where
mock_lr_scheduler = SchedulerMock(UpdateInterval.STEP)
# Mock Logging
class DummySummaryWriter(object):
def __init__(self):
self.scalar_logs = {}
def add_scalar(self, key, value, global_step=None, walltime=None) -> None:
self.scalar_logs[key] = self.scalar_logs.get(key, []) + [value]
def add_histogram(
self, key, value, global_step=None, walltime=None
) -> None:
return
def add_text(self, *args, **kwargs):
pass
def flush(self):
return
config = get_test_mlp_task_config()
config["num_epochs"] = 3
config["dataset"]["train"]["batchsize_per_replica"] = 10
config["dataset"]["test"]["batchsize_per_replica"] = 5
task = build_task(config)
writer = DummySummaryWriter()
hook = TensorboardPlotHook(writer)
hook.log_period = 1
task.set_hooks([hook])
task.set_optimizer_schedulers({"lr": mock_lr_scheduler})
trainer = LocalTrainer()
trainer.train(task)
# We have 20 samples, batch size is 10. Each epoch is done in two steps.
self.assertEqual(
writer.scalar_logs["Learning Rate/train"],
[0, 1 / 6, 2 / 6, 3 / 6, 4 / 6, 5 / 6],
)
|
ClassyVision-main
|
test/manual/hooks_tensorboard_plot_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import unittest.mock as mock
from classy_vision.hooks import ModelTensorboardHook
from classy_vision.models import build_model
from test.generic.config_utils import get_test_classy_task, get_test_model_configs
from test.generic.hook_test_utils import HookTestBase
from torch.utils.tensorboard import SummaryWriter
class TestModelTensorboardHook(HookTestBase):
def test_constructors(self) -> None:
"""
Test that the hooks are constructed correctly.
"""
config = {"summary_writer": {}}
self.constructor_test_helper(
config=config,
hook_type=ModelTensorboardHook,
hook_registry_name="model_tensorboard",
hook_kwargs={"tb_writer": SummaryWriter()},
)
@mock.patch("classy_vision.hooks.model_tensorboard_hook.is_primary")
def test_writer(self, mock_is_primary_func: mock.MagicMock) -> None:
"""
Tests that the tensorboard writer calls SummaryWriter with the model
iff is_primary() is True.
"""
mock_summary_writer = mock.create_autospec(SummaryWriter, instance=True)
task = get_test_classy_task()
task.prepare()
for primary in [False, True]:
mock_is_primary_func.return_value = primary
model_configs = get_test_model_configs()
for model_config in model_configs:
model = build_model(model_config)
task.base_model = model
# create a model tensorboard hook
model_tensorboard_hook = ModelTensorboardHook(mock_summary_writer)
model_tensorboard_hook.on_start(task)
if primary:
# SummaryWriter should have been init-ed with the correct
# add_graph should be called once with model as the first arg
mock_summary_writer.add_graph.assert_called_once()
self.assertEqual(
mock_summary_writer.add_graph.call_args[0][0], model
)
else:
# add_graph shouldn't be called since is_primary() is False
mock_summary_writer.add_graph.assert_not_called()
mock_summary_writer.reset_mock()
|
ClassyVision-main
|
test/manual/hooks_model_tensorboard_hook_test.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
|
ClassyVision-main
|
test/generic/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from classy_vision.hooks import build_hook
class HookTestBase(unittest.TestCase):
def constructor_test_helper(
self,
config,
hook_type,
hook_registry_name=None,
hook_kwargs=None,
invalid_configs=None,
):
hook_kwargs = config if hook_kwargs is None else hook_kwargs
hook1 = hook_type(**hook_kwargs)
self.assertTrue(isinstance(hook1, hook_type))
hook2 = hook_type.from_config(config)
self.assertTrue(isinstance(hook2, hook_type))
if hook_registry_name is not None:
config["name"] = hook_registry_name
hook3 = build_hook(config)
del config["name"]
self.assertTrue(isinstance(hook3, hook_type))
if invalid_configs is not None:
# Verify assert logic works correctly
for cfg in invalid_configs:
with self.assertRaises(
(AssertionError, TypeError, KeyError, ValueError)
):
hook_type.from_config(cfg)
|
ClassyVision-main
|
test/generic/hook_test_utils.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import multiprocessing
import queue
import tempfile
import unittest
import torch
UPDATE_SIGNAL = 0
VALUE_SIGNAL = 1
SHUTDOWN_SIGNAL = 2
TIMEOUT = 100
def _get_value_or_raise_error(qout, qerr):
try:
return qout.get(timeout=TIMEOUT)
except queue.Empty:
raise qerr.get(timeout=TIMEOUT)
def _run(qin, qout, qerr, func, *args):
try:
func(qin, qout, *args)
except Exception as e:
print(e)
qerr.put(e)
def _meter_worker(qin, qout, meter, is_train, world_size, rank, filename):
backend = "gloo"
torch.distributed.init_process_group(
backend=backend,
init_method="file://{filename}".format(filename=filename),
world_size=world_size,
rank=rank,
)
# Listen for commands on queues
while True:
try:
signal, val = qin.get()
except queue.Empty:
continue
if signal == UPDATE_SIGNAL:
meter.update(val[0], val[1], is_train=is_train)
elif signal == VALUE_SIGNAL:
meter.sync_state()
qout.put(meter.value)
elif signal == SHUTDOWN_SIGNAL:
break
else:
raise NotImplementedError("Bad signal value")
return
class ClassificationMeterTest(unittest.TestCase):
def setUp(self):
self.mp = multiprocessing.get_context("spawn")
self.processes = []
def tearDown(self):
for p in self.processes:
p.terminate()
def _spawn(self, func, *args):
name = "process #%d" % len(self.processes)
qin = self.mp.Queue()
qout = self.mp.Queue()
qerr = self.mp.Queue()
qio = (qin, qout, qerr)
args = qio + (func,) + args
process = self.mp.Process(target=_run, name=name, args=args, daemon=True)
process.start()
self.processes.append(process)
return qio
def _apply_updates_and_test_meter(
self, meter, model_output, target, expected_value, **kwargs
):
"""
Runs a valid meter test. Does not reset meter before / after running
"""
if not isinstance(model_output, list):
model_output = [model_output]
if not isinstance(target, list):
target = [target]
for i in range(len(model_output)):
meter.update(model_output[i], target[i], **kwargs)
meter.sync_state()
meter_value = meter.value
for key, val in expected_value.items():
self.assertTrue(
key in meter_value, msg="{0} not in meter value!".format(key)
)
if torch.is_tensor(meter_value[key]):
self.assertTrue(
torch.all(torch.eq(meter_value[key], val)),
msg="{0} meter value mismatch!".format(key),
)
else:
self.assertAlmostEqual(
meter_value[key],
val,
places=4,
msg="{0} meter value mismatch!".format(key),
)
def _values_match_expected_value(self, value0, value1, expected_value):
for key, val in expected_value.items():
self.assertTrue(key in value0, msg="{0} not in meter value!".format(key))
self.assertTrue(key in value1, msg="{0} not in meter value!".format(key))
if torch.is_tensor(val):
self.assertTrue(
torch.all(torch.eq(value0[key], val)),
"{0} meter value mismatch!".format(key),
)
self.assertTrue(
torch.all(torch.eq(value1[key], val)),
"{0} meter value mismatch!".format(key),
)
else:
self.assertAlmostEqual(
value0[key],
val,
places=4,
msg="{0} meter value mismatch!".format(key),
)
self.assertAlmostEqual(
value1[key],
val,
places=4,
msg="{0} meter value mismatch!".format(key),
)
def _validate_meter_inputs(self, meter, model_outputs, targets):
for i in range(len(model_outputs)):
meter.validate(model_outputs[i].size(), targets[i].size())
def meter_update_and_reset_test(
self, meter, model_outputs, targets, expected_value, **kwargs
):
"""
This test verifies that a single update on the meter is successful,
resets the meter, then applies the update again.
"""
# If a single output is provided, wrap in list
if not isinstance(model_outputs, list):
model_outputs = [model_outputs]
targets = [targets]
self._validate_meter_inputs(meter, model_outputs, targets)
self._apply_updates_and_test_meter(
meter, model_outputs, targets, expected_value, **kwargs
)
meter.reset()
# Verify reset works by reusing single update test
self._apply_updates_and_test_meter(
meter, model_outputs, targets, expected_value, **kwargs
)
def meter_invalid_meter_input_test(self, meter, model_output, target):
# Invalid model
with self.assertRaises(AssertionError):
meter.validate(model_output.shape, target.shape)
def meter_invalid_update_test(self, meter, model_output, target, **kwargs):
"""
Runs a valid meter test. Does not reset meter before / after running
"""
if not isinstance(model_output, list):
model_output = [model_output]
if not isinstance(target, list):
target = [target]
with self.assertRaises(AssertionError):
for i in range(len(model_output)):
meter.update(model_output[i], target[i], **kwargs)
def meter_get_set_classy_state_test(
self, meters, model_outputs, targets, expected_value, **kwargs
):
"""
Tests get and set classy state methods of meter.
"""
assert len(meters) == 2, "Incorrect number of meters passed to test"
assert (
len(model_outputs) == 2
), "Incorrect number of model_outputs passed to test"
assert len(targets) == 2, "Incorrect number of targets passed to test"
meter0 = meters[0]
meter1 = meters[1]
meter0.update(model_outputs[0], targets[0], **kwargs)
meter1.update(model_outputs[1], targets[1], **kwargs)
meter0.sync_state()
value0 = meter0.value
meter1.sync_state()
value1 = meter1.value
for key, val in value0.items():
if torch.is_tensor(value1[key]):
self.assertFalse(
torch.all(torch.eq(value1[key], val)),
msg="{0} meter values should not be same!".format(key),
)
else:
self.assertNotEqual(
value1[key],
val,
msg="{0} meter values should not be same!".format(key),
)
meter0.set_classy_state(meter1.get_classy_state())
value0 = meter0.value
for key, val in value0.items():
if torch.is_tensor(value1[key]):
self.assertTrue(
torch.all(torch.eq(value1[key], val)),
msg="{0} meter value mismatch after state transfer!".format(key),
)
self.assertTrue(
torch.all(torch.eq(value1[key], expected_value[key])),
msg="{0} meter value mismatch from ground truth!".format(key),
)
else:
self.assertAlmostEqual(
value1[key],
val,
places=4,
msg="{0} meter value mismatch after state transfer!".format(key),
)
self.assertAlmostEqual(
value1[key],
expected_value[key],
places=4,
msg="{0} meter value mismatch from ground truth!".format(key),
)
def _spawn_all_meter_workers(self, world_size, meters, is_train):
filename = tempfile.NamedTemporaryFile(delete=True).name
qins = []
qerrs = []
qouts = []
for i in range(world_size):
qin, qout, qerr = self._spawn(
_meter_worker, meters[i], is_train, world_size, i, filename
)
qins.append(qin)
qouts.append(qout)
qerrs.append(qerr)
return qins, qouts, qerrs
def meter_distributed_test(
self, meters, model_outputs, targets, expected_values, is_train=False
):
"""
Sets up two processes each with a given meter on that process.
Verifies that sync code path works.
"""
world_size = len(meters)
assert world_size == 2, "This test only works for world_size of 2"
assert len(model_outputs) == 4, (
"Test assumes 4 model outputs, "
"0, 2 passed to meter0 and 1, 3 passed to meter1"
)
assert (
len(targets) == 4
), "Test assumes 4 targets, 0, 2 passed to meter0 and 1, 3 passed to meter1"
assert len(expected_values) == 2, (
"Test assumes 2 expected values, "
"first is result of applying updates 0,1 to the meter, "
"second is result of applying all 4 updates to meter"
)
qins, qouts, qerrs = self._spawn_all_meter_workers(
world_size, meters, is_train=is_train
)
# First update each meter, then get value from each meter
qins[0].put_nowait((UPDATE_SIGNAL, (model_outputs[0], targets[0])))
qins[1].put_nowait((UPDATE_SIGNAL, (model_outputs[1], targets[1])))
qins[0].put_nowait((VALUE_SIGNAL, None))
qins[1].put_nowait((VALUE_SIGNAL, None))
value0 = _get_value_or_raise_error(qouts[0], qerrs[0])
value1 = _get_value_or_raise_error(qouts[1], qerrs[1])
self._values_match_expected_value(value0, value1, expected_values[0])
# Verify that calling value again does not break things
qins[0].put_nowait((VALUE_SIGNAL, None))
qins[1].put_nowait((VALUE_SIGNAL, None))
value0 = _get_value_or_raise_error(qouts[0], qerrs[0])
value1 = _get_value_or_raise_error(qouts[1], qerrs[1])
self._values_match_expected_value(value0, value1, expected_values[0])
# Second, update each meter, then get value from each meter
qins[0].put_nowait((UPDATE_SIGNAL, (model_outputs[2], targets[2])))
qins[1].put_nowait((UPDATE_SIGNAL, (model_outputs[3], targets[3])))
qins[0].put_nowait((VALUE_SIGNAL, None))
qins[1].put_nowait((VALUE_SIGNAL, None))
value0 = _get_value_or_raise_error(qouts[0], qerrs[0])
value1 = _get_value_or_raise_error(qouts[1], qerrs[1])
self._values_match_expected_value(value0, value1, expected_values[1])
qins[0].put_nowait((SHUTDOWN_SIGNAL, None))
qins[1].put_nowait((SHUTDOWN_SIGNAL, None))
|
ClassyVision-main
|
test/generic/meter_test_utils.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
class MergeDataset:
"""
Dataset that merges samples from multiple datasets into single sample.
If datasets have distinct keys, then we merge dicts, e.g.
dataset1[idx] = {'input': input_tensor}
dataset2[idx] = {'target': target_tensor}
merged_dataset[idx] = {'input': input_tensor, 'target': target_tensor}
If datasets have matching keys then we create a list and append, e.g.
dataset1[idx] = {'input': input_tensor1}
dataset2[idx] = {'input': input_tensor2}
merged_dataset[idx] = {'input': [input_tensor1, input_tensor2]}
Note, if your datasets' samples do not have consistent keys for each sample,
this could lead to inconsistent samples merged samples.
"""
def __init__(self, datasets):
# assertions:
assert isinstance(datasets, list)
assert all(len(dataset) == len(datasets[0]) for dataset in datasets)
# create object:
super(MergeDataset, self).__init__()
self.datasets = datasets
def __getitem__(self, idx):
final_sample = {}
for dataset in self.datasets:
curr_sample = dataset[idx]
assert isinstance(curr_sample, dict), "Merge dataset only supports dicts"
for key in curr_sample.keys():
# If keys are distinct, then
if key not in final_sample:
final_sample[key] = curr_sample[key]
elif not isinstance(final_sample[key], list):
final_sample[key] = [final_sample[key], curr_sample[key]]
else:
final_sample[key].append(curr_sample[key])
return final_sample
def __len__(self):
return len(self.datasets[0])
|
ClassyVision-main
|
test/generic/merge_dataset.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
import unittest
from functools import wraps
import torch
from classy_vision.hooks import ClassyHook
from classy_vision.tasks import ClassyTask
from classy_vision.trainer import ClassyTrainer
class Arguments(object):
"""Object that looks like input arguments. Used to spoof argparse namespace."""
def __init__(self, **args):
self.args = args
self.__dict__.update(args)
def __iter__(self):
return iter(self.args)
def __eq__(self, other):
if isinstance(other, Arguments):
return self.args == other.args
else:
return NotImplemented
def _asdict(self):
return vars(self)
def skip_if_no_gpu(func):
"""Decorator that can be used to skip GPU tests on non-GPU machines."""
func.skip_if_no_gpu = True
@wraps(func)
def wrapper(*args, **kwargs):
if not torch.cuda.is_available():
return
if torch.cuda.device_count() <= 0:
return
return func(*args, **kwargs)
return wrapper
def repeat_test(original_function=None, *, num_times=3):
"""Decorator that can be used to repeat test multiple times."""
def repeat_test_decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(num_times):
func(*args, **kwargs)
return wrapper
# this handles default arguments to decorator:
if original_function:
return repeat_test_decorator(original_function)
return repeat_test_decorator
def make_torch_deterministic(seed=0):
"""Makes Torch code run deterministically."""
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
os.environ["MKL_NUM_THREADS"] = "1"
os.environ["OMP_NUM_THREADS"] = "1"
def compare_batches(test_fixture, batch1, batch2):
"""Compare two batches. Does not do recursive comparison"""
test_fixture.assertEqual(type(batch1), type(batch2))
if isinstance(batch1, (tuple, list)):
test_fixture.assertEqual(len(batch1), len(batch2))
for n in range(len(batch1)):
value1 = batch1[n]
value2 = batch2[n]
test_fixture.assertEqual(type(value1), type(value2))
if torch.is_tensor(value1):
test_fixture.assertTrue(torch.allclose(value1, value2))
else:
test_fixture.assertEqual(value1, value2)
elif isinstance(batch1, dict):
test_fixture.assertEqual(batch1.keys(), batch2.keys())
for key, value1 in batch1.items():
value2 = batch2[key]
test_fixture.assertEqual(type(value1), type(value2))
if torch.is_tensor(value1):
test_fixture.assertTrue(torch.allclose(value1, value2))
else:
test_fixture.assertEqual(value1, value2)
def compare_datasets(test_fixture, dataset1, dataset2):
test_fixture.assertEqual(len(dataset1), len(dataset2))
for idx in range(len(dataset1)):
compare_batches(test_fixture, dataset1[idx], dataset2[idx])
def compare_batchlist_and_dataset_with_skips(
test_fixture, batch_list, dataset, skip_indices=None
):
"""
Compares a list of batches and the dataset. If some samples were
skipped in the iterator (i.e. if we simulated an error on that
sample), that should be indicated in the skip_indices list
"""
if skip_indices is None:
skip_indices = []
if isinstance(skip_indices, int):
skip_indices = [skip_indices]
skips = 0
for idx, batch in enumerate(batch_list):
while (idx + skips) in skip_indices:
skips += 1
dataset_batch = dataset[idx + skips]
compare_batches(test_fixture, batch, dataset_batch)
class MockErrorDataset:
"""
Dataset used for testing. Wraps a real dataset with a
batchsize_per_replica, but allows us to delete samples on return
to simulate errors (similar to what happens with Everstore)
"""
def __init__(self, dataset):
self.rebatch_map = {}
self.dataset = dataset
self.batchsize_per_replica = dataset.batchsize_per_replica
def __getitem__(self, idx):
batch = self.dataset[idx]
# If rebatch map contains index, resize the batch
if idx in self.rebatch_map:
num_samples = self.rebatch_map[idx]
if num_samples < batch["input"].size()[0]:
batch["input"] = batch["input"][:num_samples]
batch["target"] = batch["target"][:num_samples]
return batch
def __len__(self):
return len(self.dataset)
def recursive_unpack(batch):
"""
Takes a batch of samples, e.g.
batch = {'input': tensor([256, 3, 224, 224]), 'target': tensor([256])}
and unpacks them into a list of single samples, e.g.
[{'input': tensor([1, 3, 224, 224]), 'target': tensor([1])} ... ]
"""
new_list = []
if isinstance(batch, dict):
unpacked_dict = {}
batchsize_per_replica = -1
for key, val in batch.items():
unpacked_dict[key] = recursive_unpack(val)
batchsize_per_replica = (
len(unpacked_dict[key])
if not torch.is_tensor(unpacked_dict[key])
else 1
)
for idx in range(batchsize_per_replica):
sample = {}
for key, val in unpacked_dict.items():
sample[key] = val[idx]
new_list.append(sample)
return new_list
elif isinstance(batch, (list, tuple)):
unpacked_list = []
if isinstance(batch, tuple):
batch = list(batch)
for val in batch:
unpacked_list.append(recursive_unpack(val))
batchsize_per_replica = (
len(unpacked_list[0]) if not torch.is_tensor(unpacked_list[0]) else 1
)
for idx in range(batchsize_per_replica):
sample = []
for val in unpacked_list:
sample.append(val[idx])
if isinstance(batch, tuple):
sample = tuple(sample)
new_list.append(sample)
return new_list
elif torch.is_tensor(batch):
for i in range(batch.size()[0]):
new_list.append(batch[i])
return new_list
raise TypeError("Unexpected type %s passed to unpack" % type(batch))
def compare_model_state(test_fixture, state, state2, check_heads=True):
for k in state["model"]["trunk"].keys():
if not torch.allclose(state["model"]["trunk"][k], state2["model"]["trunk"][k]):
print(k, state["model"]["trunk"][k], state2["model"]["trunk"][k])
test_fixture.assertTrue(
torch.allclose(state["model"]["trunk"][k], state2["model"]["trunk"][k])
)
if check_heads:
for block, head_states in state["model"]["heads"].items():
for head_id, states in head_states.items():
for k in states.keys():
test_fixture.assertTrue(
torch.allclose(
state["model"]["heads"][block][head_id][k],
state2["model"]["heads"][block][head_id][k],
)
)
def compare_samples(test_fixture, sample1, sample2):
test_fixture.assertEqual(sample1.keys(), sample2.keys())
test_fixture.assertTrue(torch.is_tensor(sample1["input"]))
test_fixture.assertTrue(torch.is_tensor(sample2["input"]))
test_fixture.assertTrue(torch.is_tensor(sample1["target"]))
test_fixture.assertTrue(torch.is_tensor(sample2["target"]))
test_fixture.assertTrue(torch.allclose(sample1["input"], sample2["input"]))
test_fixture.assertTrue(torch.allclose(sample1["target"], sample2["target"]))
def compare_states(test_fixture, state_1, state_2, check_heads=True):
"""
Tests the classy state dicts for equality, but skips the member objects
which implement their own {get, set}_classy_state functions.
"""
# check base_model
compare_model_state(
test_fixture, state_1["base_model"], state_2["base_model"], check_heads
)
# check losses
test_fixture.assertEqual(len(state_1["losses"]), len(state_2["losses"]))
for loss_1, loss_2 in zip(state_1["losses"], state_2["losses"]):
test_fixture.assertAlmostEqual(loss_1, loss_2)
for key in ["base_model", "meters", "optimizer", "losses"]:
# we trust that these have been tested using their unit tests or
# by the code above
test_fixture.assertIn(key, state_1)
test_fixture.assertIn(key, state_2)
del state_1[key]
del state_2[key]
test_fixture.assertDictEqual(state_1, state_2)
class LimitedPhaseException(Exception):
pass
class LimitedPhaseHook(ClassyHook):
on_start = ClassyHook._noop
on_phase_start = ClassyHook._noop
on_step = ClassyHook._noop
on_end = ClassyHook._noop
def __init__(self, num_phases: int):
self.num_phases = num_phases
self.phase_counter = 0
def on_phase_end(self, task):
if self.phase_counter >= self.num_phases:
raise LimitedPhaseException
self.phase_counter += 1
class LimitedPhaseTrainer(ClassyTrainer):
def __init__(self, num_phases: int):
self.num_phases = num_phases
def train(self, task: ClassyTask):
task.hooks = task.hooks + [LimitedPhaseHook(self.num_phases)]
try:
super().train(task)
except LimitedPhaseException:
pass
class ClassyTestCase(unittest.TestCase):
def assertTorchAllClose(
self, tensor_1, tensor_2, rtol=1e-5, atol=1e-8, equal_nan=False
):
for tensor in [tensor_1, tensor_2]:
if not isinstance(tensor, torch.Tensor):
raise AssertionError(
f"Expected tensor, not {tensor} of type {type(tensor)}"
)
if not torch.allclose(
tensor_1, tensor_2, rtol=rtol, atol=atol, equal_nan=equal_nan
):
raise AssertionError(f"{tensor_1} is not close to {tensor_2}")
|
ClassyVision-main
|
test/generic/utils.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from abc import ABC, abstractmethod
from unittest.mock import MagicMock
import torch
import torch.nn as nn
from classy_vision.generic.util import split_batchnorm_params
from classy_vision.models import ClassyModel
from classy_vision.optim import build_optimizer, build_optimizer_schedulers
from classy_vision.optim.param_scheduler import LinearParamScheduler
class TestOptimizer(ABC):
@abstractmethod
def _get_config(self):
pass
@abstractmethod
def _instance_to_test(self):
pass
def _check_momentum_buffer(self):
return False
def _parameters(self, requires_grad=True):
return [
torch.tensor([[1.0, 2.0]], requires_grad=requires_grad),
torch.tensor([[3.0, 4.0]], requires_grad=requires_grad),
]
def _set_gradient(self, params, grad_values=None):
if grad_values is None:
grad_values = [0.1, 0.1]
for i in range(len(params)):
params[i].grad = torch.tensor([grad_values])
def _compare_momentum_values(self, optim1, optim2):
self.assertEqual(len(optim1["param_groups"]), len(optim2["param_groups"]))
for i in range(len(optim1["param_groups"])):
self.assertEqual(
len(optim1["param_groups"][i]["params"]),
len(optim2["param_groups"][i]["params"]),
)
if self._check_momentum_buffer():
for j in range(len(optim1["param_groups"][i]["params"])):
id1 = optim1["param_groups"][i]["params"][j]
id2 = optim2["param_groups"][i]["params"][j]
self.assertTrue(
torch.allclose(
optim1["state"][id1]["momentum_buffer"],
optim2["state"][id2]["momentum_buffer"],
)
)
def _get_set_state(self, grad_values):
config = self._get_config()
opt1 = build_optimizer(config)
opt1.set_param_groups(self._parameters(), lr=1, momentum=0.9)
self.assertIsInstance(opt1, self._instance_to_test())
self._set_gradient(self._parameters(), grad_values)
opt1.step(where=0)
if config["name"] == "zero":
opt1.consolidate_state_dict()
state = opt1.get_classy_state()
opt2 = build_optimizer(config)
opt2.set_param_groups(self._parameters(), lr=2)
self.assertNotEqual(opt1.options_view.lr, opt2.options_view.lr)
opt2.set_classy_state(state)
self.assertEqual(opt1.options_view.lr, opt2.options_view.lr)
for i in range(len(opt1.optimizer.param_groups[0]["params"])):
self.assertTrue(
torch.allclose(
opt1.optimizer.param_groups[0]["params"][i],
opt2.optimizer.param_groups[0]["params"][i],
)
)
if config["name"] == "zero":
opt2.consolidate_state_dict()
self._compare_momentum_values(
opt1.get_classy_state()["optim"], opt2.get_classy_state()["optim"]
)
# check if the optimizers behave the same on params update
mock_classy_vision_model1 = self._parameters()
mock_classy_vision_model2 = self._parameters()
self._set_gradient(mock_classy_vision_model1, grad_values)
self._set_gradient(mock_classy_vision_model2, grad_values)
opt1 = build_optimizer(config)
opt1.set_param_groups(mock_classy_vision_model1)
opt2 = build_optimizer(config)
opt2.set_param_groups(mock_classy_vision_model2)
opt1.step(where=0)
opt2.step(where=0)
for i in range(len(opt1.optimizer.param_groups[0]["params"])):
print(opt1.optimizer.param_groups[0]["params"][i])
self.assertTrue(
torch.allclose(
opt1.optimizer.param_groups[0]["params"][i],
opt2.optimizer.param_groups[0]["params"][i],
)
)
if config["name"] == "zero":
opt1.consolidate_state_dict()
opt2.consolidate_state_dict()
self._compare_momentum_values(
opt1.get_classy_state()["optim"], opt2.get_classy_state()["optim"]
)
def test_build_sgd(self):
config = self._get_config()
opt = build_optimizer(config)
opt.set_param_groups(self._parameters())
self.assertTrue(isinstance(opt, self._instance_to_test()))
def test_get_set_state(self):
for grad_values in [[0.1, 0.1], [-0.1, -0.1], [0.0, 0.0], [0.1, -0.1]]:
self._get_set_state(grad_values)
def test_set_invalid_state(self):
config = self._get_config()
opt = build_optimizer(config)
opt.set_param_groups(self._parameters())
self.assertTrue(isinstance(opt, self._instance_to_test()))
with self.assertRaises(KeyError):
opt.set_classy_state({})
def test_lr_schedule(self):
config = self._get_config()
opt = build_optimizer(config)
param_schedulers = build_optimizer_schedulers(config)
opt.set_param_groups({"params": self._parameters(), **param_schedulers})
# Test initial learning rate
for group in opt.optimizer.param_groups:
self.assertEqual(group["lr"], 0.1)
def _test_lr_schedule(optimizer, num_epochs, epochs, targets):
for i in range(len(epochs)):
epoch = epochs[i]
target = targets[i]
param_groups = optimizer.optimizer.param_groups.copy()
optimizer.on_epoch(epoch / num_epochs)
for idx, group in enumerate(optimizer.optimizer.param_groups):
self.assertEqual(group["lr"], target)
# Make sure all but LR is same
param_groups[idx]["lr"] = target
self.assertEqual(param_groups[idx], group)
# Test constant learning schedule
num_epochs = 90
epochs = [0, 0.025, 0.05, 0.1, 0.5, 1, 15, 29, 30, 31, 59, 60, 61, 88, 89]
targets = [0.1] * 15
_test_lr_schedule(opt, num_epochs, epochs, targets)
# Test step learning schedule
config["param_schedulers"] = {
"lr": {"name": "step", "values": [0.1, 0.01, 0.001]}
}
opt = build_optimizer(config)
param_schedulers = build_optimizer_schedulers(config)
opt.set_param_groups({"params": self._parameters(), **param_schedulers})
targets = [0.1] * 8 + [0.01] * 3 + [0.001] * 4
_test_lr_schedule(opt, num_epochs, epochs, targets)
# Test step learning schedule with warmup
init_lr = 0.01
warmup_epochs = 0.1
config["param_schedulers"] = {
"lr": {
"name": "composite",
"schedulers": [
{"name": "linear", "start_value": init_lr, "end_value": 0.1},
{"name": "step", "values": [0.1, 0.01, 0.001]},
],
"update_interval": "epoch",
"interval_scaling": ["rescaled", "fixed"],
"lengths": [warmup_epochs / num_epochs, 1 - warmup_epochs / num_epochs],
}
}
opt = build_optimizer(config)
param_schedulers = build_optimizer_schedulers(config)
opt.set_param_groups({"params": self._parameters(), **param_schedulers})
targets = [0.01, 0.0325, 0.055] + [0.1] * 5 + [0.01] * 3 + [0.001] * 4
_test_lr_schedule(opt, num_epochs, epochs, targets)
def test_set_param_groups(self):
opt = build_optimizer(self._get_config())
# This must crash since we're missing the .set_param_groups call
with self.assertRaises(RuntimeError):
opt.step(where=0)
def test_step_args(self):
opt = build_optimizer(self._get_config())
opt.set_param_groups([torch.tensor([1.0], requires_grad=True)])
# where argument must be named explicitly
with self.assertRaises(RuntimeError):
opt.step(0)
# this shouldn't crash
opt.step(where=0)
def test_get_lr(self):
opt = build_optimizer(self._get_config())
param = torch.tensor([1.0], requires_grad=True)
opt.set_param_groups([{"params": [param], "lr": 1}])
self.assertEqual(opt.options_view.lr, 1)
# Case two: verify LR changes
opt = build_optimizer(self._get_config())
param = torch.tensor([1.0], requires_grad=True)
opt.set_param_groups([{"params": [param], "lr": LinearParamScheduler(1, 2)}])
self.assertAlmostEqual(opt.options_view.lr, 1)
opt.step(where=0.5)
self.assertAlmostEqual(opt.options_view.lr, 1.5)
def test_batchnorm_weight_decay(self):
class MyModel(nn.Module):
def __init__(self):
super().__init__()
self.lin = nn.Linear(2, 3)
self.relu = nn.ReLU()
self.bn = nn.BatchNorm1d(3)
def forward(self, x):
return self.bn(self.relu(self.lin(x)))
torch.manual_seed(1)
model = MyModel()
opt = build_optimizer(self._get_config())
bn_params, lin_params = split_batchnorm_params(model)
lin_param_before = model.lin.weight.detach().clone()
bn_param_before = model.bn.weight.detach().clone()
with torch.enable_grad():
x = torch.tensor([[1.0, 1.0], [1.0, 2.0]])
out = model(x).pow(2).sum()
out.backward()
opt.set_param_groups(
[
{
"params": lin_params,
"lr": LinearParamScheduler(1, 2),
"weight_decay": 0.5,
},
{"params": bn_params, "lr": 0, "weight_decay": 0},
]
)
opt.step(where=0.5)
# Make sure the linear parameters are trained but not the batch norm
self.assertFalse(torch.allclose(model.lin.weight, lin_param_before))
self.assertTrue(torch.allclose(model.bn.weight, bn_param_before))
opt.step(where=0.5)
# Same, but after another step and triggering the lr scheduler
self.assertFalse(torch.allclose(model.lin.weight, lin_param_before))
self.assertTrue(torch.allclose(model.bn.weight, bn_param_before))
|
ClassyVision-main
|
test/generic/optim_test_util.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import sys
from classy_vision.tasks import build_task
def get_test_task_config(head_num_classes=1000):
return {
"name": "classification_task",
"num_epochs": 12,
"loss": {"name": "CrossEntropyLoss"},
"dataset": {
"train": {
"name": "synthetic_image",
"crop_size": 224,
"class_ratio": 0.5,
"num_samples": 2000,
"seed": 0,
"batchsize_per_replica": 32,
"num_workers": 1,
"use_shuffle": True,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
],
"key": "input",
}
],
},
"test": {
"name": "synthetic_image",
"crop_size": 224,
"class_ratio": 0.5,
"num_samples": 2000,
"seed": 0,
"batchsize_per_replica": 32,
"num_workers": 1,
"use_shuffle": False,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
],
"key": "input",
}
],
},
},
"meters": {"accuracy": {"topk": [1, 5]}},
"model": {
"name": "resnet",
"num_blocks": [3, 4, 6, 3],
"small_input": False,
"zero_init_bn_residuals": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": head_num_classes,
"fork_block": "block3-2",
"in_plane": 2048,
}
],
},
"optimizer": {
"name": "sgd",
"num_epochs": 12,
"param_schedulers": {"lr": {"name": "step", "values": [0.1, 0.01]}},
"weight_decay": 1e-4,
"momentum": 0.9,
},
}
def get_fast_test_task_config(head_num_classes=1000):
return {
"name": "classification_task",
"num_epochs": 1,
"loss": {"name": "CrossEntropyLoss"},
"dataset": {
"train": {
"name": "synthetic_image",
"crop_size": 20,
"class_ratio": 0.5,
"num_samples": 10,
"seed": 0,
"batchsize_per_replica": 2,
"num_workers": 1,
"use_shuffle": False,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
],
"key": "input",
}
],
},
"test": {
"name": "synthetic_image",
"crop_size": 20,
"class_ratio": 0.5,
"num_samples": 10,
"seed": 0,
"batchsize_per_replica": 2,
"num_workers": 1,
"use_shuffle": False,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
],
"key": "input",
}
],
},
},
"model": {
"name": "resnet",
"num_blocks": [1],
"small_input": False,
"zero_init_bn_residuals": True,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": head_num_classes,
"fork_block": "block0-0",
"in_plane": 256,
}
],
},
"meters": {"accuracy": {"topk": [1]}},
"optimizer": {"name": "sgd", "lr": 0.01, "weight_decay": 1e-4, "momentum": 0.9},
}
def get_test_classy_task():
config = get_test_task_config()
task = build_task(config)
return task
def get_test_mlp_task_config():
return {
"name": "classification_task",
"num_epochs": 10,
"loss": {"name": "CrossEntropyLoss"},
"dataset": {
"train": {
"name": "synthetic_image",
"num_classes": 2,
"crop_size": 20,
"class_ratio": 0.5,
"num_samples": 20,
"seed": 0,
"batchsize_per_replica": 6,
"use_augmentation": False,
"use_shuffle": True,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
],
"key": "input",
}
],
},
"test": {
"name": "synthetic_image",
"num_classes": 2,
"crop_size": 20,
"class_ratio": 0.5,
"num_samples": 10,
"seed": 0,
"batchsize_per_replica": 1,
"use_augmentation": False,
"use_shuffle": False,
"transforms": [
{
"name": "apply_transform_to_key",
"transforms": [
{"name": "ToTensor"},
{
"name": "Normalize",
"mean": [0.485, 0.456, 0.406],
"std": [0.229, 0.224, 0.225],
},
],
"key": "input",
}
],
},
},
"model": {
"name": "mlp",
# 3x20x20 = 1200
"input_dim": 1200,
"output_dim": 1000,
"hidden_dims": [10],
"use_batchnorm": True, # used for testing sync batchnorm
},
"meters": {"accuracy": {"topk": [1]}},
"optimizer": {
"name": "sgd",
"num_epochs": 10,
"lr": 0.1,
"weight_decay": 1e-4,
"momentum": 0.9,
},
}
def get_test_model_configs():
return [
# resnet 50
{
"name": "resnet",
"num_blocks": [3, 4, 6, 3],
"small_input": False,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-2",
"in_plane": 2048,
}
],
},
# resnet 101
{
"name": "resnet",
"num_blocks": [3, 4, 23, 3],
"small_input": False,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-2",
"in_plane": 2048,
}
],
},
# resnext 101 32x4d
{
"name": "resnext",
"num_blocks": [3, 4, 23, 3],
"base_width_and_cardinality": [4, 32],
"small_input": False,
"heads": [
{
"name": "fully_connected",
"unique_id": "default_head",
"num_classes": 1000,
"fork_block": "block3-2",
"in_plane": 2048,
}
],
},
]
def get_test_video_task_config():
return {
"name": "classification_task",
"num_epochs": 27,
"loss": {"name": "CrossEntropyLoss"},
"dataset": {
"train": {
"name": "synthetic_video",
"split": "train",
"batchsize_per_replica": 8,
"use_shuffle": True,
"num_samples": 128,
"frames_per_clip": 8,
"video_height": 128,
"video_width": 160,
"num_classes": 50,
"clips_per_video": 1,
},
"test": {
"name": "synthetic_video",
"split": "test",
"batchsize_per_replica": 10,
"use_shuffle": False,
"num_samples": 40,
"frames_per_clip": 8,
"video_height": 128,
"video_width": 160,
"num_classes": 50,
"clips_per_video": 10,
},
},
"meters": {"accuracy": {"topk": [1, 5]}},
"model": {
"name": "resnext3d",
"frames_per_clip": 8,
"input_planes": 3,
"clip_crop_size": 224,
"skip_transformation_type": "postactivated_shortcut",
"residual_transformation_type": "postactivated_bottleneck_transformation",
"num_blocks": [3, 4, 6, 3],
"input_key": "video",
"stem_name": "resnext3d_stem",
"stem_planes": 64,
"stem_temporal_kernel": 5,
"stem_spatial_kernel": 7,
"stem_maxpool": True,
"stage_planes": 64,
"stage_temporal_kernel_basis": [[3], [3, 1], [3, 1], [1, 3]],
"temporal_conv_1x1": [True, True, True, True],
"stage_temporal_stride": [1, 1, 1, 1],
"stage_spatial_stride": [1, 2, 2, 2],
"num_groups": 1,
"width_per_group": 64,
"num_classes": 50,
"heads": [
{
"name": "fully_convolutional_linear",
"unique_id": "default_head",
"pool_size": [8, 7, 7],
"activation_func": "softmax",
"num_classes": 50,
"fork_block": "pathway0-stage4-block2",
"in_plane": 512,
"use_dropout": True,
}
],
},
"optimizer": {
"name": "sgd",
"param_schedulers": {
"lr": {
"name": "multistep",
"num_epochs": 10,
"values": [0.1, 0.01, 0.001, 0.0001],
"milestones": [3, 7, 9],
}
},
"weight_decay": 0.0001,
"momentum": 0.9,
},
}
def get_test_classy_video_task():
config = get_test_video_task_config()
task = build_task(config)
return task
def get_distributed_launch_cmd(num_processes: int, trainer_path: str, config_path: str):
return f"""{sys.executable} -m torch.distributed.launch \
--nnodes=1 \
--nproc_per_node={num_processes} \
--master_addr=localhost \
--master_port=29500 \
--use_env \
{trainer_path} \
--config={config_path} \
--log_freq=100 \
--distributed_backend=ddp
"""
|
ClassyVision-main
|
test/generic/config_utils.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
|
ClassyVision-main
|
hydra_plugins/classy_vision_path/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from hydra.core.config_search_path import ConfigSearchPath
from hydra.plugins.search_path_plugin import SearchPathPlugin
class ClassyVisionPathPlugin(SearchPathPlugin):
def manipulate_search_path(self, search_path: ConfigSearchPath) -> None:
search_path.append(
provider="classy_vision", path="pkg://classy_vision.hydra.conf"
)
|
ClassyVision-main
|
hydra_plugins/classy_vision_path/classy_vision_path.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
sys.path.insert(0, os.path.abspath(".."))
# -- Project information -----------------------------------------------------
project = "Classy Vision"
copyright = "2019, Facebook AI Research"
author = "Facebook AI Research"
# The full version, including alpha/beta/rc tags
release = "0.1"
# -- General configuration ---------------------------------------------------
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named "sphinx.ext.*") or your custom
# ones.
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.autosummary",
"sphinx.ext.githubpages",
"sphinx.ext.napoleon",
"sphinx.ext.intersphinx",
"sphinx.ext.mathjax",
]
autodoc_default_flags = ["undoc-members"]
autodoc_default_options = {
"special-members": "__init__,__call__",
"autodoc_typehints": "none",
}
primary_domain = "py"
intersphinx_mapping = {
"python": ("https://docs.python.org/3", None),
"pytorch": ("https://pytorch.org/docs/stable", None),
}
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This pattern also affects html_static_path and html_extra_path.
exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"]
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = "alabaster"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
# html_static_path = ["_static"]
html_static_path = [] # for now we have no static files to track
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# The default sidebars (for documents that don't match any pattern) are
# defined by theme itself. Builtin themes are using these templates by
# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
# 'searchbox.html']``.
#
# html_sidebars = {}
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
html_show_sphinx = False
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
html_show_copyright = False
|
ClassyVision-main
|
sphinx/conf.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import json
import os
import nbformat
from bs4 import BeautifulSoup
from nbconvert import HTMLExporter, ScriptExporter
TEMPLATE = """const CWD = process.cwd();
const React = require('react');
const Tutorial = require(`${{CWD}}/core/Tutorial.js`);
class TutorialPage extends React.Component {{
render() {{
const {{config: siteConfig}} = this.props;
const {{baseUrl}} = siteConfig;
return <Tutorial baseUrl={{baseUrl}} tutorialID="{}"/>;
}}
}}
module.exports = TutorialPage;
"""
JS_SCRIPTS = """
<script
src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js">
</script>
<script
src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.0.3/jquery.min.js">
</script>
""" # noqa: E501
def gen_tutorials(repo_dir: str) -> None:
"""Generate HTML tutorials for captum Docusaurus site from Jupyter notebooks.
Also create ipynb and py versions of tutorial in Docusaurus site for
download.
"""
with open(os.path.join(repo_dir, "website", "tutorials.json"), "r") as infile:
tutorial_config = json.loads(infile.read())
tutorial_ids = {x["id"] for v in tutorial_config.values() for x in v}
for tid in tutorial_ids:
print("Generating {} tutorial".format(tid))
# convert notebook to HTML
ipynb_in_path = os.path.join(repo_dir, "tutorials", "{}.ipynb".format(tid))
with open(ipynb_in_path, "r") as infile:
nb_str = infile.read()
nb = nbformat.reads(nb_str, nbformat.NO_CONVERT)
# displayname is absent from notebook metadata
nb["metadata"]["kernelspec"]["display_name"] = "python3"
exporter = HTMLExporter()
html, meta = exporter.from_notebook_node(nb)
# pull out html div for notebook
soup = BeautifulSoup(html, "html.parser")
nb_meat = soup.find("body", {"class": "jp-Notebook"})
nb_meat.attrs["class"] = ["notebook"]
html_out = JS_SCRIPTS + str(nb_meat)
# generate html file
html_out_path = os.path.join(
repo_dir, "website", "_tutorials", "{}.html".format(tid)
)
with open(html_out_path, "w") as html_outfile:
html_outfile.write(html_out)
# generate JS file
script = TEMPLATE.format(tid)
js_out_path = os.path.join(
repo_dir, "website", "pages", "tutorials", "{}.js".format(tid)
)
with open(js_out_path, "w") as js_outfile:
js_outfile.write(script)
# output tutorial in both ipynb & py form
ipynb_out_path = os.path.join(
repo_dir, "website", "static", "files", "{}.ipynb".format(tid)
)
with open(ipynb_out_path, "w") as ipynb_outfile:
ipynb_outfile.write(nb_str)
exporter = ScriptExporter()
script, meta = exporter.from_notebook_node(nb)
py_out_path = os.path.join(
repo_dir, "website", "static", "files", "{}.py".format(tid)
)
with open(py_out_path, "w") as py_outfile:
py_outfile.write(script)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Generate JS, HTML, ipynb, and py files for tutorials."
)
parser.add_argument(
"-w", "--repo_dir", metavar="path", required=True, help="captum repo directory."
)
args = parser.parse_args()
gen_tutorials(args.repo_dir)
|
ClassyVision-main
|
scripts/parse_tutorials.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import os
from bs4 import BeautifulSoup
js_scripts = """
<script type="text/javascript" id="documentation_options" data-url_root="./"
src="/js/documentation_options.js"></script>
<script type="text/javascript" src="/js/jquery.js"></script>
<script type="text/javascript" src="/js/underscore.js"></script>
<script type="text/javascript" src="/js/doctools.js"></script>
<script type="text/javascript" src="/js/language_data.js"></script>
<script type="text/javascript" src="/js/searchtools.js"></script>
""" # noqa: E501
search_js_scripts = """
<script type="text/javascript">
jQuery(function() { Search.loadIndex("/js/searchindex.js"); });
</script>
<script type="text/javascript" id="searchindexloader"></script>
"""
def parse_sphinx(input_dir, output_dir):
for cur, _, files in os.walk(input_dir):
for fname in files:
if fname.endswith(".html"):
with open(os.path.join(cur, fname), "r") as f:
soup = BeautifulSoup(f.read(), "html.parser")
doc = soup.find("div", {"class": "document"})
wrapped_doc = doc.wrap(soup.new_tag("div", **{"class": "sphinx"}))
# add js
if fname == "search.html":
out = js_scripts + search_js_scripts + str(wrapped_doc)
else:
out = js_scripts + str(wrapped_doc)
output_path = os.path.join(output_dir, os.path.relpath(cur, input_dir))
os.makedirs(output_path, exist_ok=True)
with open(os.path.join(output_path, fname), "w") as fout:
fout.write(out)
# update reference in JS file
with open(os.path.join(input_dir, "_static/searchtools.js"), "r") as js_file:
js = js_file.read()
js = js.replace(
"DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/'", "'_sphinx-sources/'"
)
with open(os.path.join(input_dir, "_static/searchtools.js"), "w") as js_file:
js_file.write(js)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Strip HTML body from Sphinx docs.")
parser.add_argument(
"-i",
"--input_dir",
metavar="path",
required=True,
help="Input directory for Sphinx HTML.",
)
parser.add_argument(
"-o",
"--output_dir",
metavar="path",
required=True,
help="Output directory in Docusaurus.",
)
args = parser.parse_args()
parse_sphinx(args.input_dir, args.output_dir)
|
ClassyVision-main
|
scripts/parse_sphinx.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
__version__ = "0.7.0"
|
ClassyVision-main
|
classy_vision/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict, List, Optional
import torch
from torch import Tensor
from . import build_loss, ClassyLoss, register_loss
@register_loss("sum_arbitrary")
class SumArbitraryLoss(ClassyLoss):
"""
Sums a collection of (weighted) torch.nn losses.
NOTE: this applies all the losses to the same output and does not support
taking a list of outputs as input.
"""
def __init__(
self, losses: List[ClassyLoss], weights: Optional[Tensor] = None
) -> None:
super().__init__()
if weights is None:
weights = torch.ones((len(losses)))
self.losses = losses
self.weights = weights
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "SumArbitraryLoss":
"""Instantiates a SumArbitraryLoss from a configuration.
Args:
config: A configuration for a SumArbitraryLoss.
See :func:`__init__` for parameters expected in the config.
Returns:
A SumArbitraryLoss instance.
"""
assert (
type(config["losses"]) == list and len(config["losses"]) > 0
), "losses must be a list of registered losses with length > 0"
assert type(config["weights"]) == list and len(config["weights"]) == len(
config["losses"]
), "weights must be None or a list and have same length as losses"
loss_modules = []
for loss_config in config["losses"]:
loss_modules.append(build_loss(loss_config))
assert all(
isinstance(loss_module, ClassyLoss) for loss_module in loss_modules
), "All losses must be registered, valid ClassyLosses"
return cls(losses=loss_modules, weights=config.get("weights", None))
def forward(self, prediction, target):
for idx, loss in enumerate(self.losses):
current_loss = loss(prediction, target)
if idx == 0:
total_loss = current_loss
else:
total_loss = total_loss.add(self.weights[idx], current_loss)
return total_loss
|
ClassyVision-main
|
classy_vision/losses/sum_arbitrary_loss.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import copy
import traceback
from pathlib import Path
import torch
import torch.nn.modules.loss as torch_losses
from classy_vision.generic.registry_utils import import_all_modules
from classy_vision.generic.util import log_class_usage
from .classy_loss import ClassyLoss
FILE_ROOT = Path(__file__).parent
LOSS_REGISTRY = {}
LOSS_REGISTRY_TB = {}
LOSS_CLASS_NAMES = set()
LOSS_CLASS_NAMES_TB = {}
def build_loss(config):
"""Builds a ClassyLoss from a config.
This assumes a 'name' key in the config which is used to determine what
model class to instantiate. For instance, a config `{"name": "my_loss",
"foo": "bar"}` will find a class that was registered as "my_loss"
(see :func:`register_loss`) and call .from_config on it.
In addition to losses registered with :func:`register_loss`, we also
support instantiating losses available in the `torch.nn.modules.loss <https:
//pytorch.org/docs/stable/nn.html#loss-functions>`_
module. Any keys in the config will get expanded to parameters of the loss
constructor. For instance, the following call will instantiate a
`torch.nn.modules.CrossEntropyLoss <https://pytorch.org/docs/stable/
nn.html#torch.nn.CrossEntropyLoss>`_:
.. code-block:: python
build_loss({"name": "CrossEntropyLoss", "reduction": "sum"})
"""
assert "name" in config, f"name not provided for loss: {config}"
name = config["name"]
args = copy.deepcopy(config)
del args["name"]
if "weight" in args and args["weight"] is not None:
# if we are passing weights, we need to change the weights from a list
# to a tensor
args["weight"] = torch.tensor(args["weight"], dtype=torch.float)
if name in LOSS_REGISTRY:
loss = LOSS_REGISTRY[name].from_config(config)
else:
# the name should be available in torch.nn.modules.loss
assert hasattr(torch_losses, name), (
f"{name} isn't a registered loss"
", nor is it available in torch.nn.modules.loss"
)
loss = getattr(torch_losses, name)(**args)
log_class_usage("Loss", loss.__class__)
return loss
def register_loss(name, bypass_checks=False):
"""Registers a ClassyLoss subclass.
This decorator allows Classy Vision to instantiate a subclass of
ClassyLoss from a configuration file, even if the class itself is not
part of the Classy Vision framework. To use it, apply this decorator to a
ClassyLoss subclass, like this:
.. code-block:: python
@register_loss("my_loss")
class MyLoss(ClassyLoss):
...
To instantiate a loss from a configuration file, see
:func:`build_loss`."""
def register_loss_cls(cls):
if not bypass_checks:
if name in LOSS_REGISTRY:
msg = (
"Cannot register duplicate loss ({}). Already registered at \n{}\n"
)
raise ValueError(msg.format(name, LOSS_REGISTRY_TB[name]))
if not issubclass(cls, ClassyLoss):
raise ValueError(
"Loss ({}: {}) must extend ClassyLoss".format(name, cls.__name__)
)
tb = "".join(traceback.format_stack())
LOSS_REGISTRY[name] = cls
LOSS_CLASS_NAMES.add(cls.__name__)
LOSS_REGISTRY_TB[name] = tb
LOSS_CLASS_NAMES_TB[cls.__name__] = tb
return cls
return register_loss_cls
# automatically import any Python files in the losses/ directory
import_all_modules(FILE_ROOT, "classy_vision.losses")
from .barron_loss import BarronLoss # isort:skip
from .label_smoothing_loss import LabelSmoothingCrossEntropyLoss # isort:skip
from .multi_output_sum_loss import MultiOutputSumLoss # isort:skip
from .soft_target_cross_entropy_loss import SoftTargetCrossEntropyLoss # isort:skip
from .sum_arbitrary_loss import SumArbitraryLoss # isort:skip
__all__ = [
"BarronLoss",
"ClassyLoss",
"LabelSmoothingCrossEntropyLoss",
"MultiOutputSumLoss",
"SoftTargetCrossEntropyLoss",
"SumArbitraryLoss",
"build_loss",
"register_loss",
]
|
ClassyVision-main
|
classy_vision/losses/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict
import torch
from . import build_loss, ClassyLoss, register_loss
@register_loss("multi_output_sum_loss")
class MultiOutputSumLoss(ClassyLoss):
"""
Applies the provided loss to the list of outputs (or single output) and sums
up the losses.
"""
def __init__(self, loss) -> None:
super().__init__()
self._loss = loss
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "MultiOutputSumLoss":
"""Instantiates a MultiOutputSumLoss from a configuration.
Args:
config: A configuration for a MultiOutpuSumLoss.
See :func:`__init__` for parameters expected in the config.
Returns:
A MultiOutputSumLoss instance.
"""
assert (
type(config["loss"]) == dict
), "loss must be a dict containing a configuration for a registered loss"
return cls(loss=build_loss(config["loss"]))
def forward(self, output, target):
if torch.is_tensor(output):
output = [output]
loss = 0
for pred in output:
loss += self._loss(pred, target)
return loss
|
ClassyVision-main
|
classy_vision/losses/multi_output_sum_loss.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict
import torch.nn as nn
class ClassyLoss(nn.Module):
"""
Base class to calculate the loss during training.
This implementation of :class:`torch.nn.Module` allows building
the loss object from a configuration file.
"""
def __init__(self):
"""
Constructor for ClassyLoss.
"""
super(ClassyLoss, self).__init__()
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "ClassyLoss":
"""Instantiates a ClassyLoss from a configuration.
Args:
config: A configuration for a ClassyLoss.
Returns:
A ClassyLoss instance.
"""
raise NotImplementedError()
def forward(self, output, target):
"""
Compute the loss for the provided sample.
Refer to :class:`torch.nn.Module` for more details.
"""
raise NotImplementedError
def get_classy_state(self) -> Dict[str, Any]:
"""Get the state of the ClassyLoss.
The returned state is used for checkpointing. Note that most losses are
stateless and do not need to save any state.
Returns:
A state dictionary containing the state of the loss.
"""
return self.state_dict()
def set_classy_state(self, state: Dict[str, Any]) -> None:
"""Set the state of the ClassyLoss.
Args:
state_dict: The state dictionary. Must be the output of a call to
:func:`get_classy_state`.
This is used to load the state of the loss from a checkpoint. Note
that most losses are stateless and do not need to load any state.
"""
return self.load_state_dict(state)
def has_learned_parameters(self) -> bool:
"""Does this loss have learned parameters?"""
return any(param.requires_grad for param in self.parameters(recurse=True))
|
ClassyVision-main
|
classy_vision/losses/classy_loss.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict
import torch
from . import ClassyLoss, register_loss
@register_loss("barron")
class BarronLoss(ClassyLoss):
"""
This implements the `Barron loss <https://arxiv.org/pdf/1701.03077.pdf>`_.
"""
def __init__(self, alpha, size_average, c):
super(BarronLoss, self).__init__()
self.size_average = size_average
self.alpha = alpha
self.c = c
self.z = max(1.0, 2.0 - self.alpha)
# define all three losses:
def _forward_zero(diff):
out = diff.div(self.c).pow(2.0).mul(0.5).add(1.0).log()
return out
def _forward_inf(diff):
out = 1.0 - diff.div(self.c).pow(2.0).mul(-0.5).exp()
return out
def _forward(diff):
out = diff.div(self.c).pow(2.0).div(self.z).add(1.0).pow(self.alpha / 2.0)
out.add_(-1.0).mul_(self.z / self.alpha)
return out
# set the correct loss:
if self.alpha == 0.0:
self._forward = _forward_zero
elif self.alpha == -float("inf") or self.alpha == float("inf"):
self._forward = _forward_inf
else:
self._forward = _forward
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "BarronLoss":
"""Instantiates a BarronLoss from a configuration.
Args:
config: A configuration for a BarronLoss.
See :func:`__init__` for parameters expected in the config.
Returns:
A BarronLoss instance.
"""
# Infinity is a valid alpha value but is frequently a string
config["alpha"] = float(config["alpha"])
# assertions:
assert type(config["size_average"]) == bool
assert type(config["alpha"]) == float
assert type(config["c"]) == float and config["c"] > 0.0
return cls(
alpha=config["alpha"], size_average=config["size_average"], c=config["c"]
)
def forward(self, prediction, target):
diff = torch.add(prediction, -target)
loss = self._forward(diff)
loss = loss.sum(0, keepdim=True)
if self.size_average:
loss.div_(prediction.size(0))
return loss
|
ClassyVision-main
|
classy_vision/losses/barron_loss.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict
import torch
import torch.nn.functional as F
from classy_vision.generic.util import convert_to_one_hot
from classy_vision.losses import ClassyLoss, register_loss
@register_loss("soft_target_cross_entropy")
class SoftTargetCrossEntropyLoss(ClassyLoss):
def __init__(self, ignore_index=-100, reduction="mean", normalize_targets=True):
"""Intializer for the soft target cross-entropy loss loss.
This allows the targets for the cross entropy loss to be multilabel
Args:
ignore_index: sample should be ignored for loss if the class is this value
reduction: specifies reduction to apply to the output
normalize_targets: whether the targets should be normalized to a sum of 1
based on the total count of positive targets for a given sample
"""
super(SoftTargetCrossEntropyLoss, self).__init__()
self._ignore_index = ignore_index
self._reduction = reduction
assert isinstance(normalize_targets, bool)
self._normalize_targets = normalize_targets
if self._reduction not in ["none", "mean"]:
raise NotImplementedError(
'reduction type "{}" not implemented'.format(self._reduction)
)
self._eps = torch.finfo(torch.float32).eps
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "SoftTargetCrossEntropyLoss":
"""Instantiates a SoftTargetCrossEntropyLoss from a configuration.
Args:
config: A configuration for a SoftTargetCrossEntropyLoss.
See :func:`__init__` for parameters expected in the config.
Returns:
A SoftTargetCrossEntropyLoss instance.
"""
return cls(
ignore_index=config.get("ignore_index", -100),
reduction=config.get("reduction", "mean"),
normalize_targets=config.get("normalize_targets", True),
)
def forward(self, output, target):
"""for N examples and C classes
- output: N x C these are raw outputs (without softmax/sigmoid)
- target: N x C or N corresponding targets
Target elements set to ignore_index contribute 0 loss.
Samples where all entries are ignore_index do not contribute to the loss
reduction.
"""
# check if targets are inputted as class integers
if target.ndim == 1:
assert (
output.shape[0] == target.shape[0]
), "SoftTargetCrossEntropyLoss requires output and target to have same batch size"
target = convert_to_one_hot(target.view(-1, 1), output.shape[1])
assert output.shape == target.shape, (
"SoftTargetCrossEntropyLoss requires output and target to be same "
f"shape: {output.shape} != {target.shape}"
)
valid_mask = target != self._ignore_index
valid_targets = target.float() * valid_mask.float()
if self._normalize_targets:
valid_targets /= self._eps + valid_targets.sum(dim=1, keepdim=True)
per_sample_per_target_loss = -valid_targets * F.log_softmax(output, -1)
per_sample_loss = torch.sum(per_sample_per_target_loss, -1)
# perform reduction
if self._reduction == "mean":
# normalize based on the number of samples with > 0 non-ignored targets
loss = per_sample_loss.sum() / torch.sum(
(torch.sum(valid_mask, -1) > 0)
).clamp(min=1)
elif self._reduction == "none":
loss = per_sample_loss
return loss
|
ClassyVision-main
|
classy_vision/losses/soft_target_cross_entropy_loss.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict
import numpy as np
from classy_vision.generic.util import convert_to_one_hot
from classy_vision.losses import ClassyLoss, register_loss
from classy_vision.losses.soft_target_cross_entropy_loss import (
SoftTargetCrossEntropyLoss,
)
@register_loss("label_smoothing_cross_entropy")
class LabelSmoothingCrossEntropyLoss(ClassyLoss):
def __init__(self, ignore_index=-100, reduction="mean", smoothing_param=None):
"""Intializer for the label smoothed cross entropy loss.
This decreases gap between output scores and encourages generalization.
Targets provided to forward can be one-hot vectors (NxC) or class indices (Nx1).
This normalizes the targets to a sum of 1 based on the total count of positive
targets for a given sample before applying label smoothing.
Args:
ignore_index: sample should be ignored for loss if the class is this value
reduction: specifies reduction to apply to the output
smoothing_param: value to be added to each target entry
"""
super().__init__()
self._ignore_index = ignore_index
self._reduction = reduction
self._smoothing_param = smoothing_param
self.loss_function = SoftTargetCrossEntropyLoss(
self._ignore_index, self._reduction, normalize_targets=False
)
self._eps = np.finfo(np.float32).eps
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "LabelSmoothingCrossEntropyLoss":
"""Instantiates a LabelSmoothingCrossEntropyLoss from a configuration.
Args:
config: A configuration for a LabelSmoothingCrossEntropyLoss.
See :func:`__init__` for parameters expected in the config.
Returns:
A LabelSmoothingCrossEntropyLoss instance.
"""
assert (
"smoothing_param" in config
), "Label Smoothing needs a smoothing parameter"
return cls(
ignore_index=config.get("ignore_index", -100),
reduction=config.get("reduction", "mean"),
smoothing_param=config.get("smoothing_param"),
)
def compute_valid_targets(self, target, classes):
"""
This function takes one-hot or index target vectors and computes valid one-hot
target vectors, based on ignore index value
"""
target_shape_list = list(target.size())
valid_mask = target != self._ignore_index
valid_targets = target.float() * valid_mask.float()
# check if targets are inputted as class integers
if len(target_shape_list) == 1 or (
len(target_shape_list) == 2 and target_shape_list[1] == 1
):
valid_targets = convert_to_one_hot(valid_targets.view(-1, 1), classes)
valid_targets = valid_targets.float() * valid_mask.view(-1, 1).float()
return valid_targets
def smooth_targets(self, valid_targets, classes):
"""
This function takes valid (No ignore values present) one-hot target vectors
and computes smoothed target vectors (normalized) according to the loss's
smoothing parameter
"""
valid_targets /= self._eps + valid_targets.sum(dim=1, keepdim=True)
if classes > 0:
smoothed_targets = valid_targets + (self._smoothing_param / classes)
smoothed_targets /= self._eps + smoothed_targets.sum(dim=1, keepdim=True)
return smoothed_targets
def forward(self, output, target):
valid_targets = self.compute_valid_targets(
target=target, classes=output.shape[1]
)
assert (
valid_targets.shape == output.shape
), "LabelSmoothingCrossEntropyLoss requires output and target to be same size"
smoothed_targets = self.smooth_targets(
valid_targets=valid_targets, classes=output.shape[1]
)
return self.loss_function(output, smoothed_targets)
|
ClassyVision-main
|
classy_vision/losses/label_smoothing_loss.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Dict
from classy_vision.generic.util import (
load_and_broadcast_checkpoint,
update_classy_model,
)
from classy_vision.tasks import ClassificationTask, register_task
@register_task("fine_tuning")
class FineTuningTask(ClassificationTask):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.pretrained_checkpoint_dict = None
self.pretrained_checkpoint_path = None
self.pretrained_checkpoint_load_strict = True
self.reset_heads = False
self.freeze_trunk = False
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "FineTuningTask":
"""Instantiates a FineTuningTask from a configuration.
Args:
config: A configuration for a FineTuningTask.
See :func:`__init__` for parameters expected in the config.
Returns:
A FineTuningTask instance.
"""
task = super().from_config(config)
pretrained_checkpoint_path = config.get("pretrained_checkpoint")
if pretrained_checkpoint_path:
task.set_pretrained_checkpoint(pretrained_checkpoint_path)
task.set_pretrained_checkpoint_load_strict(
config.get("pretrained_checkpoint_load_strict", True)
)
task.set_reset_heads(config.get("reset_heads", False))
task.set_freeze_trunk(config.get("freeze_trunk", False))
return task
def set_pretrained_checkpoint(self, checkpoint_path: str) -> "FineTuningTask":
self.pretrained_checkpoint_path = checkpoint_path
return self
def set_pretrained_checkpoint_load_strict(
self, pretrained_checkpoint_load_strict: bool
):
self.pretrained_checkpoint_load_strict = pretrained_checkpoint_load_strict
return self
def _set_pretrained_checkpoint_dict(
self, checkpoint_dict: Dict[str, Any]
) -> "FineTuningTask":
self.pretrained_checkpoint_dict = checkpoint_dict
return self
def set_reset_heads(self, reset_heads: bool) -> "FineTuningTask":
self.reset_heads = reset_heads
return self
def set_freeze_trunk(self, freeze_trunk: bool) -> "FineTuningTask":
self.freeze_trunk = freeze_trunk
return self
def _set_model_train_mode(self):
phase = self.phases[self.phase_idx]
self.loss.train(phase["train"])
if self.freeze_trunk:
# convert all the sub-modules to the eval mode, except the heads
self.base_model.eval()
for heads in self.base_model.get_heads().values():
for h in heads:
h.train(phase["train"])
else:
self.base_model.train(phase["train"])
def prepare(self) -> None:
super().prepare()
if self.checkpoint_dict is None:
# no checkpoint exists, load the model's state from the pretrained
# checkpoint
if self.pretrained_checkpoint_path:
self.pretrained_checkpoint_dict = load_and_broadcast_checkpoint(
self.pretrained_checkpoint_path
)
assert (
self.pretrained_checkpoint_dict is not None
), "Need a pretrained checkpoint for fine tuning"
state_load_success = update_classy_model(
self.base_model,
self.pretrained_checkpoint_dict["classy_state_dict"]["base_model"],
self.reset_heads,
self.pretrained_checkpoint_load_strict,
)
assert (
state_load_success
), "Update classy state from pretrained checkpoint was unsuccessful."
if self.freeze_trunk:
# do not track gradients for all the parameters in the model except
# for the parameters in the heads
for param in self.base_model.parameters():
param.requires_grad = False
for heads in self.base_model.get_heads().values():
for h in heads:
for param in h.parameters():
param.requires_grad = True
# re-create ddp model
self.distributed_model = None
self.init_distributed_data_parallel_model()
|
ClassyVision-main
|
classy_vision/tasks/fine_tuning_task.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from abc import ABC, abstractmethod
from typing import Any, Dict
from classy_vision.generic.util import log_class_usage
class ClassyTask(ABC):
"""
An abstract base class for a training task.
A ClassyTask encapsulates all the components and steps needed
to train using a :class:`classy_vision.trainer.ClassyTrainer`.
"""
def __init__(self) -> "ClassyTask":
"""
Constructs a ClassyTask.
"""
self.hooks = []
log_class_usage("Task", self.__class__)
@classmethod
@abstractmethod
def from_config(cls, config: Dict[str, Any]) -> "ClassyTask":
"""Instantiates a ClassyTask from a configuration.
Args:
config: A configuration for a ClassyTask.
Returns:
A ClassyTask instance.
"""
raise NotImplementedError()
@property
@abstractmethod
def where(self) -> float:
"""
Tells how far along (where) we are during training.
Returns:
A float in [0, 1) which tells the training progress.
"""
pass
@abstractmethod
def done_training(self) -> bool:
"""
Tells if we are done training.
Returns:
A boolean telling if training is over.
"""
pass
@abstractmethod
def get_classy_state(self, deep_copy: bool = False) -> Dict[str, Any]:
"""Get the state of the ClassyTask.
The returned state is used for checkpointing.
Args:
deep_copy: If True, creates a deep copy of the state dict. Otherwise, the
returned dict's state will be tied to the object's.
Returns:
A state dictionary containing the state of the task.
"""
pass
@abstractmethod
def set_classy_state(self, state):
"""Set the state of the ClassyTask.
Args:
state_dict: The state dictionary. Must be the output of a call to
:func:`get_classy_state`.
This is used to load the state of the task from a checkpoint.
"""
pass
@abstractmethod
def prepare(self, num_dataloader_workers=0, dataloader_mp_context=None) -> None:
"""
Prepares the task for training.
Will be called by the :class:`classy_vision.trainer.ClassyTrainer` to
prepare the task, before on_start is called.
Args:
num_dataloader_workers: Number of workers to create for the dataloaders
pin_memory: Whether the dataloaders should copy the Tensors into CUDA
pinned memory (default False)
"""
pass
@abstractmethod
def train_step(self) -> None:
"""
Run a train step.
This corresponds to training over one batch of data from the dataloaders.
"""
pass
@abstractmethod
def on_start(self):
"""
Start training.
Called by :class:`classy_vision.trainer.ClassyTrainer` before training starts.
"""
pass
@abstractmethod
def on_phase_start(self):
"""
Epoch start.
Called by :class:`classy_vision.trainer.ClassyTrainer` before each epoch starts.
"""
pass
@abstractmethod
def on_phase_end(self):
"""
Epoch end.
Called by :class:`classy_vision.trainer.ClassyTrainer` after each epoch ends.
"""
pass
@abstractmethod
def on_end(self):
"""
Training end.
Called by :class:`classy_vision.trainer.ClassyTrainer` after training ends.
"""
pass
@abstractmethod
def eval_step(self) -> None:
"""
Run an evaluation step.
This corresponds to evaluating the model over one batch of data.
"""
pass
def step(self) -> None:
from classy_vision.hooks import ClassyHookFunctions
if self.train:
self.train_step()
else:
self.eval_step()
for hook in self.hooks:
hook.on_step(self)
def run_hooks(self, local_variables: Dict[str, Any], hook_function: str) -> None:
"""
Helper function that runs a hook function for all the
:class:`classy_vision.hooks.ClassyHook`.
Args:
local_variables: Local variables created in :func:`train_step`
hook_function: One of the hook functions in the
:class:`classy_vision.hooks.ClassyHookFunctions`
enum.
"""
for hook in self.hooks:
getattr(hook, hook_function)(self, local_variables)
|
ClassyVision-main
|
classy_vision/tasks/classy_task.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import traceback
from pathlib import Path
from classy_vision.generic.registry_utils import import_all_modules
from .classy_task import ClassyTask
FILE_ROOT = Path(__file__).parent
TASK_REGISTRY = {}
TASK_CLASS_NAMES = set()
TASK_REGISTRY_TB = {}
TASK_CLASS_NAMES_TB = {}
def build_task(config):
"""Builds a ClassyTask from a config.
This assumes a 'name' key in the config which is used to determine what
task class to instantiate. For instance, a config `{"name": "my_task",
"foo": "bar"}` will find a class that was registered as "my_task"
(see :func:`register_task`) and call .from_config on it."""
task = TASK_REGISTRY[config["name"]].from_config(config)
return task
def register_task(name):
"""Registers a ClassyTask subclass.
This decorator allows Classy Vision to instantiate a subclass of ClassyTask
from a configuration file, even if the class itself is not part of the
Classy Vision framework. To use it, apply this decorator to a ClassyTask
subclass, like this:
.. code-block:: python
@register_task('my_task')
class MyTask(ClassyTask):
...
To instantiate a task from a configuration file, see :func:`build_task`."""
def register_task_cls(cls):
if name in TASK_REGISTRY:
msg = "Cannot register duplicate task ({}). Already registered at \n{}\n"
raise ValueError(msg.format(name, TASK_REGISTRY_TB[name]))
if not issubclass(cls, ClassyTask):
raise ValueError(
"Task ({}: {}) must extend ClassyTask".format(name, cls.__name__)
)
if cls.__name__ in TASK_CLASS_NAMES:
msg = (
"Cannot register task with duplicate class name({})."
+ "Previously registered at \n{}\n"
)
raise ValueError(
msg.format(cls.__name__, TASK_CLASS_NAMES_TB[cls.__name__])
)
tb = "".join(traceback.format_stack())
TASK_REGISTRY[name] = cls
TASK_CLASS_NAMES.add(cls.__name__)
TASK_REGISTRY_TB[name] = tb
TASK_CLASS_NAMES_TB[cls.__name__] = tb
return cls
return register_task_cls
from .classification_task import ClassificationTask # isort:skip
from .fine_tuning_task import FineTuningTask # isort:skip
__all__ = [
"ClassyTask",
"FineTuningTask",
"build_task",
"register_task",
"ClassificationTask",
]
# automatically import any Python files in the tasks/ directory
import_all_modules(FILE_ROOT, "classy_vision.tasks")
|
ClassyVision-main
|
classy_vision/tasks/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import contextlib
import copy
import enum
import json
import logging
import math
import multiprocessing as mp
import time
from typing import Any, Dict, List, NamedTuple, Optional, Union
import torch
import torch.nn as nn
from classy_vision.dataset import build_dataset, ClassyDataset
from classy_vision.dataset.transforms.mixup import MixupTransform
from classy_vision.generic.distributed_util import (
all_reduce_mean,
barrier,
init_distributed_data_parallel_model,
is_distributed_training_run,
)
from classy_vision.generic.util import (
copy_model_to_gpu,
get_torch_version,
load_and_broadcast_checkpoint,
master_params,
recursive_copy_to_gpu,
split_batchnorm_params,
Timer,
update_classy_state,
)
from classy_vision.hooks import build_hooks, CheckpointHook, ClassyHook
from classy_vision.losses import build_loss, ClassyLoss
from classy_vision.meters import build_meters, ClassyMeter
from classy_vision.models import build_model, ClassyModel
from classy_vision.optim import (
build_optimizer,
build_optimizer_schedulers,
ClassyOptimizer,
)
from classy_vision.optim.zero import ZeRO
from torch.distributed import broadcast
from . import register_task
from .classy_task import ClassyTask
try:
import apex
apex_available = True
except ImportError:
apex_available = False
try:
from torch.cuda.amp import GradScaler as TorchGradScaler
except ImportError:
pass
try:
from fairscale.optim.grad_scaler import ShardedGradScaler
fairscale_available = True
except ImportError:
fairscale_available = False
class AmpType(enum.Enum):
# Automatic Mixed Precision supported types
APEX = enum.auto()
PYTORCH = enum.auto()
class BroadcastBuffersMode(enum.Enum):
DISABLED = enum.auto()
# Enable DistributedDataParallel's broadcast_buffers option, synchronizing
# model buffers every forward pass.
FORWARD_PASS = enum.auto()
# Similar to FORWARD_PASS, but only synchronizes model buffers once
# per epoch, between train and test phases. If your motivation for
# synchronizing buffers is for buffers to be consistent during eval, use
# this instead of FORWARD_PASS to reduce training overhead.
BEFORE_EVAL = enum.auto()
class BatchNormSyncMode(enum.Enum):
DISABLED = enum.auto() # No Synchronized Batch Normalization
PYTORCH = enum.auto() # Use torch.nn.SyncBatchNorm
APEX = enum.auto() # Use apex.parallel.SyncBatchNorm, needs apex to be installed
class LastBatchInfo(NamedTuple):
loss: torch.Tensor
output: torch.Tensor
target: torch.Tensor
sample: Dict[str, Any]
step_data: Dict[str, Any]
@register_task("classification_task")
class ClassificationTask(ClassyTask):
"""Basic classification training task.
This task encapsultates all of the components and steps needed to
train a classifier using a :class:`classy_vision.trainer.ClassyTrainer`.
Assumes a train / test phase per each epoch and that the datasets
have the same API as the map-style Dataset class in
`torch.utils.data.dataset <https://pytorch.org/docs/stable/data.html
#torch.utils.data.Dataset>`_ (in particular, this task makes use of
the len). If you are using an `IterableDataset <https://pytorch.org/docs/
stable/data.html#torch.utils.data.IterableDataset>`_ then a custom task
may be appropriate.
:var loss: Loss (see :class:`classy_vision.losses.ClassyLoss`) function used
for computing the loss in each forward pass
:var datasets: Mapping from a ``phase_type`` in ["train", "test']
to dataset used for training (or testing)
:var meters: List of meters (see :class:`classy_vision.meters.ClassyMeter`)
to calculate during training
:var num_epochs: Number of epochs (passes over dataset) to train
:var test_only: Used to only run the test phase
:var base_model: Model to be trained, unwrapped in DDP or DP wrappers
:var optimizer: Optimizer used in train step
:var optimizer_schedulers: Dictionary. Key is the name of the optimizer
option (e.g. lr), value is a ClassyParamScheduler
:var checkpoint: Serializable dict which represents state in training
:var phases: List of phase specific information, e.g. if phase is
train / test.
:var hooks: List of hooks to apply during training
:var train: Phase type, if true it means we are training,
false means testing
:var distributed_model: Base model, but wrapped in DDP (DistributedDataParallel)
:var phase_idx: Current phase id, first phase is 0, if task has not started
training then returns -1
:var train_phase_idx: Only counts train phases
:var num_updates: Number of total parameter updates applied to model
by the optimizer
:var data_iterator: Iterator which can be used to obtain batches
:var losses: Loss curve
:var perf_log: list of training speed measurements, to be logged
:var clip_grad_norm: maximum gradient norm (default None)
:var simulated_global_batchsize: batch size simulated via gradient accumulation
:var optimizer_period: apply optimizer after this many steps; derived from
simulated_global_batchsize, default 1.
"""
def __init__(self):
"""Constructs a ClassificationTask"""
super().__init__()
self.base_loss = None
self.datasets = {}
self.meters = []
self.num_epochs = 1
self.test_phase_period = 1
self.train_phases_per_epoch = 0
self.test_only = False
self.base_model = None
self.optimizer = None
self.optimizer_schedulers = {}
self.checkpoint_dict = None
self.checkpoint_path = None
self.checkpoint_load_strict = True
self.phases = []
self.hooks = []
self.train = True
self.distributed_model = None
self.distributed_loss = None
self.phase_idx = -1
self.train_phase_idx = -1
self.num_updates = 0
self.dataloader = None
self.data_iterator = None
self.losses = []
self.broadcast_buffers_mode: BroadcastBuffersMode = (
BroadcastBuffersMode.BEFORE_EVAL
)
self.amp_args = None
self.amp_type = None
self.amp_grad_scaler = None
self.mixup_transform = None
self.perf_log = []
self.last_batch = None
self.batch_norm_sync_mode = BatchNormSyncMode.DISABLED
self.find_unused_parameters = False
self.use_gpu = torch.cuda.is_available()
self.dataloader_mp_context = "spawn"
self.bn_weight_decay = False
self._train_only = True
self.clip_grad_norm = None
self.simulated_global_batchsize = None
self.optimizer_period = 1
self.ddp_bucket_cap_mb = 25
self.use_sharded_ddp = False
self.fp16_grad_compress = False
def set_use_sharded_ddp(self, use_sharded_ddp: bool):
self.use_sharded_ddp = use_sharded_ddp
if self.use_sharded_ddp:
logging.info("Using Sharded DDP")
return self
def set_use_gpu(self, use_gpu: bool):
self.use_gpu = use_gpu
assert (
not self.use_gpu or torch.cuda.is_available()
), "CUDA required to train on GPUs"
return self
def set_clip_grad_norm(self, clip_grad_norm: Optional[float]):
"""Sets maximum gradient norm.
None means gradient clipping is disabled. Defaults to None."""
self.clip_grad_norm = clip_grad_norm
if clip_grad_norm is None:
logging.info("Disabled gradient norm clipping.")
else:
logging.info(
f"Enabled gradient norm clipping with threshold: {clip_grad_norm}"
)
return self
def set_simulated_global_batchsize(self, simulated_global_batchsize: Optional[int]):
"""Sets a simulated batch size by gradient accumulation.
Gradient accumulation adds up gradients from multiple minibatches and
steps the optimizer every N train_steps, where N is optimizer_period.
When enabled, the very last train_steps might end up not updating the
model, depending on the number of total steps. None means gradient
accumulation is disabled. Defaults to None."""
self.simulated_global_batchsize = simulated_global_batchsize
return self
def set_checkpoint(self, checkpoint_path: str):
"""Sets checkpoint on task.
Args:
checkpoint_path: The path to load the checkpoint from. Can be a file or a
directory. See :func:`load_checkpoint` for more information.
"""
self.checkpoint_path = checkpoint_path
return self
def set_checkpoint_load_strict(self, checkpoint_load_strict: bool):
"""Sets checkpoint on task.
Args:
checkpoint_load_strict: Whether to use load_strict when copying model weights
"""
self.checkpoint_load_strict = checkpoint_load_strict
return self
def _set_checkpoint_dict(self, checkpoint_dict: Dict[str, Any]):
"""Sets the checkpoint dict in the task. Only used for testing.
Args:
checkpoint_dict: A serializable dict representing current task state
"""
self.checkpoint_dict = checkpoint_dict
return self
def set_num_epochs(self, num_epochs: Union[int, float]):
"""Set number of epochs to be run.
Args:
num_epochs: Number of epochs to run task
"""
self.num_epochs = num_epochs
return self
def set_test_phase_period(self, test_phase_period: int):
"""Set the period of test phase.
Args:
test_phase_period: The period of test phase
"""
self.test_phase_period = test_phase_period
return self
def set_dataset(self, dataset: ClassyDataset, phase_type: str):
"""Set dataset for phase type on task
Args:
dataset: ClassyDataset for returning samples.
phase_type: str must be one of "train" or "test"
"""
assert phase_type in [
"train",
"test",
], "phase_type must be in ['train', 'test']"
self.datasets[phase_type] = dataset
if phase_type == "train":
self.train_phases_per_epoch = getattr(dataset, "phases_per_epoch", 1)
else:
self._train_only = False
return self
def set_dataloader_mp_context(self, dataloader_mp_context: Optional[str]):
"""Set the multiprocessing context used by the dataloader.
The context can be either 'spawn', 'fork', 'forkserver' or None (uses the
default context). See
https://docs.python.org/3/library/multiprocessing.html#multiprocessing.get_context
for more details."""
self.dataloader_mp_context = dataloader_mp_context
return self
def set_optimizer(self, optimizer: ClassyOptimizer):
"""Set optimizer for task
Args:
optimizer: optimizer for task
"""
self.optimizer = optimizer
return self
def set_loss(self, loss: ClassyLoss):
"""Set loss function for task
Args:
loss: loss for task
"""
self.base_loss = loss
return self
def set_meters(self, meters: List["ClassyMeter"]):
"""Set meters for task
Args:
meters: list of meters to compute during training
"""
self.meters = meters
return self
def set_distributed_options(
self,
broadcast_buffers_mode: BroadcastBuffersMode = BroadcastBuffersMode.BEFORE_EVAL,
batch_norm_sync_mode: BatchNormSyncMode = BatchNormSyncMode.DISABLED,
batch_norm_sync_group_size: int = 0,
find_unused_parameters: bool = False,
bucket_cap_mb: int = 25,
fp16_grad_compress: bool = False,
):
"""Set distributed options.
Args:
broadcast_buffers_mode: Broadcast buffers mode. See
:class:`BroadcastBuffersMode` for options.
batch_norm_sync_mode: Batch normalization synchronization mode. See
:class:`BatchNormSyncMode` for options.
batch_norm_sync_group_size: Group size to use for synchronized batch norm.
0 means that the stats are synchronized across all replicas. For
efficient synchronization, set it to the number of GPUs in a node (
usually 8).
find_unused_parameters: See
:class:`torch.nn.parallel.DistributedDataParallel` for information.
bucket_cap_mb: See
:class:`torch.nn.parallel.DistributedDataParallel` for information.
Raises:
RuntimeError: If batch_norm_sync_mode is `BatchNormSyncMode.APEX` and apex
is not installed.
"""
self.broadcast_buffers_mode = broadcast_buffers_mode
if batch_norm_sync_group_size > 0:
if not batch_norm_sync_mode == BatchNormSyncMode.APEX:
# this should ideally work with PyTorch Sync BN as well, but it
# fails while initializing DDP for some reason.
raise ValueError(
"batch_norm_sync_group_size can be > 0 only when "
"Apex Synchronized Batch Normalization is being used."
)
self.batch_norm_sync_group_size = batch_norm_sync_group_size
if batch_norm_sync_mode == BatchNormSyncMode.DISABLED:
logging.info("Synchronized Batch Normalization is disabled")
else:
if batch_norm_sync_mode == BatchNormSyncMode.APEX and not apex_available:
raise RuntimeError("apex is not installed")
msg = f"Using Synchronized Batch Normalization using {batch_norm_sync_mode}"
if self.batch_norm_sync_group_size > 0:
msg += f" and group size {batch_norm_sync_group_size}"
logging.info(msg)
self.batch_norm_sync_mode = batch_norm_sync_mode
if find_unused_parameters:
logging.info("Enabling find_unused_parameters in DDP")
self.find_unused_parameters = find_unused_parameters
self.ddp_bucket_cap_mb = bucket_cap_mb
if fp16_grad_compress:
if get_torch_version() < [1, 8]:
raise RuntimeError(
"FP16 grad compression is only supported since PyTorch 1.8"
)
logging.info("Enabling FP16 grad compression")
self.fp16_grad_compress = fp16_grad_compress
return self
def set_hooks(self, hooks: List["ClassyHook"]):
"""Set hooks for task
Args:
hooks: List of hooks to apply during training
"""
from classy_vision.hooks import ClassyHook
assert isinstance(hooks, list)
assert all(isinstance(hook, ClassyHook) for hook in hooks)
assert len({hook.name() for hook in hooks}) == len(
hooks
), "Cannot have repeated hooks of the same class"
# TODO (zyan3): we move checkpoint hook to the end of the list because some hooks
# may change the state of the model, and we want to save changed state in the checkpoint.
# This is temporary fix.
non_checkpoint_hooks = [
hook for hook in hooks if not isinstance(hook, CheckpointHook)
]
checkpoint_hooks = [hook for hook in hooks if isinstance(hook, CheckpointHook)]
hooks = non_checkpoint_hooks + checkpoint_hooks
self.hooks = hooks
return self
def set_model(self, model: ClassyModel):
"""Set model for task
Args:
model: Model to be trained
"""
self.base_model = model
return self
def set_test_only(self, test_only: bool):
"""Set test only flag
Args:
test_only: If true, only test phases will be run
"""
self.test_only = test_only
return self
def set_bn_weight_decay(self, bn_weight_decay: bool):
assert type(bn_weight_decay) == bool
self.bn_weight_decay = bn_weight_decay
return self
def set_amp_args(self, amp_args: Optional[Dict[str, Any]]):
"""Disable / enable apex.amp and set the automatic mixed precision parameters.
apex.amp can be utilized for mixed / half precision training.
Args:
amp_args: Dictionary containing arguments to be passed to
amp.initialize. Set to None to disable amp. To enable mixed
precision training, pass amp_args={"opt_level": "O1"} here.
See https://nvidia.github.io/apex/amp.html for more info.
Raises:
RuntimeError: If opt_level is not None and apex is not installed.
Warning: apex needs to be installed to utilize this feature.
"""
self.amp_args = amp_args
if amp_args is None:
logging.info("AMP disabled")
else:
# Check that the requested AMP type is known
try:
self.amp_type = AmpType[self.amp_args["amp_type"].upper()]
except KeyError:
logging.info("AMP type not specified, defaulting to Apex")
self.amp_type = AmpType.APEX
# Check for CUDA availability, required for both Apex and Pytorch AMP
if not torch.cuda.is_available():
raise RuntimeError(
"AMP is required but CUDA is not supported, cannot enable AMP"
)
# Check for Apex availability
if self.amp_type == AmpType.APEX and not apex_available:
raise RuntimeError(
"Apex AMP is required but Apex is not installed, cannot enable AMP"
)
if self.use_sharded_ddp:
if self.amp_type == AmpType.APEX:
raise RuntimeError(
"ShardedDDP has been requested, which is incompatible with Apex AMP"
)
if not fairscale_available:
raise RuntimeError(
"ShardedDDP has been requested, but fairscale is not installed in the current environment"
)
# Set Torch AMP grad scaler, used to prevent gradient underflow
elif self.amp_type == AmpType.PYTORCH:
if self.use_sharded_ddp:
logging.info("Using ShardedGradScaler to manage Pytorch AMP")
self.amp_grad_scaler = ShardedGradScaler()
else:
self.amp_grad_scaler = TorchGradScaler()
logging.info(f"AMP enabled with args {amp_args}")
return self
def set_mixup_transform(self, mixup_transform: Optional["MixupTransform"]):
"""Disable / enable mixup transform for data augmentation
Args::
mixup_transform: a callable object which performs mixup data augmentation
"""
self.mixup_transform = mixup_transform
if mixup_transform is None:
logging.info("mixup disabled")
else:
logging.info("mixup enabled")
return self
def set_optimizer_schedulers(self, schedulers):
self.optimizer_schedulers = schedulers
return self
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "ClassificationTask":
"""Instantiates a ClassificationTask from a configuration.
Args:
config: A configuration for a ClassificationTask.
See :func:`__init__` for parameters expected in the config.
Returns:
A ClassificationTask instance.
"""
test_only = config.get("test_only", False)
if not test_only:
# TODO Make distinction between epochs and phases in optimizer clear
train_phases_per_epoch = config["dataset"]["train"].get(
"phases_per_epoch", 1
)
optimizer_config = config["optimizer"]
optimizer_config["num_epochs"] = (
config["num_epochs"] * train_phases_per_epoch
)
optimizer = build_optimizer(optimizer_config)
param_schedulers = build_optimizer_schedulers(optimizer_config)
datasets = {}
phase_types = ["train", "test"]
for phase_type in phase_types:
if phase_type in config["dataset"]:
datasets[phase_type] = build_dataset(config["dataset"][phase_type])
loss = build_loss(config["loss"])
amp_args = config.get("amp_args")
meters = build_meters(config.get("meters", {}))
model = build_model(config["model"])
mixup_transform = None
if config.get("mixup") is not None:
assert "alpha" in config["mixup"], "key alpha is missing in mixup dict"
mixup_transform = MixupTransform(
config["mixup"]["alpha"],
num_classes=config["mixup"].get("num_classes"),
cutmix_alpha=config["mixup"].get("cutmix_alpha", 0),
cutmix_minmax=config["mixup"].get("cutmix_minmax"),
mix_prob=config["mixup"].get("mix_prob", 1.0),
switch_prob=config["mixup"].get("switch_prob", 0.5),
mode=config["mixup"].get("mode", "batch"),
label_smoothing=config["mixup"].get("label_smoothing", 0.0),
)
# hooks config is optional
hooks_config = config.get("hooks")
hooks = []
if hooks_config is not None:
hooks = build_hooks(hooks_config)
distributed_config = config.get("distributed", {})
distributed_options = {
"broadcast_buffers_mode": BroadcastBuffersMode[
distributed_config.get("broadcast_buffers", "before_eval").upper()
],
"batch_norm_sync_mode": BatchNormSyncMode[
distributed_config.get("batch_norm_sync_mode", "disabled").upper()
],
"batch_norm_sync_group_size": distributed_config.get(
"batch_norm_sync_group_size", 0
),
"find_unused_parameters": distributed_config.get(
"find_unused_parameters", False
),
"bucket_cap_mb": distributed_config.get("bucket_cap_mb", 25),
"fp16_grad_compress": distributed_config.get("fp16_grad_compress", False),
}
task = (
cls()
.set_num_epochs(config["num_epochs"])
.set_test_phase_period(config.get("test_phase_period", 1))
.set_loss(loss)
.set_test_only(test_only)
.set_model(model)
.set_meters(meters)
.set_amp_args(amp_args)
.set_mixup_transform(mixup_transform)
.set_distributed_options(**distributed_options)
.set_hooks(hooks)
.set_bn_weight_decay(config.get("bn_weight_decay", False))
.set_clip_grad_norm(config.get("clip_grad_norm"))
.set_simulated_global_batchsize(config.get("simulated_global_batchsize"))
.set_use_sharded_ddp(config.get("use_sharded_ddp", False))
)
if not test_only:
task.set_optimizer(optimizer)
task.set_optimizer_schedulers(param_schedulers)
use_gpu = config.get("use_gpu")
if use_gpu is not None:
task.set_use_gpu(use_gpu)
for phase_type in datasets:
task.set_dataset(datasets[phase_type], phase_type)
# NOTE: this is a private member and only meant to be used for
# logging/debugging purposes. See __repr__ implementation
task._config = config
return task
@property
def num_batches_per_phase(self):
"""Returns number of batches in current phase iterator"""
return len(self.data_iterator)
@property
def model(self):
"""Returns model used in training (can be wrapped with DDP)"""
return (
self.distributed_model if is_distributed_training_run() else self.base_model
)
@property
def loss(self):
"""Returns loss used in training (can be wrapped with DDP)"""
return self.distributed_loss if self.distributed_loss else self.base_loss
@property
def phase_type(self):
"""Returns current phase type. String with value "train" or "test" """
return "train" if self.train else "test"
@property
def eval_phase_idx(self):
"""Returns current evaluation phase"""
return self.phase_idx - self.train_phase_idx - 1
def get_total_training_phases(self):
"""
Returns the total number of "train" phases in the task
"""
num_training_phases = 0
for phase in self.phases:
if phase["train"] is True:
num_training_phases += 1
return num_training_phases
def get_total_test_phases(self):
"""
Returns the total number of "test" phases in the task
"""
num_test_phases = 0
for phase in self.phases:
if phase["train"] is False:
num_test_phases += 1
return num_test_phases
def _build_phases(self):
"""Returns list of phases from config.
These phases will look like:
{
train: is this a train or test phase?
optimizer: optimizer settings
}
- If this is a test only run, then only test phases will be
generated
- If this is a training run with both train and test datasets, then x phases =
x train phases + x test phases, interleaved. If test_phase_period > 1, test
phases are only added after test_phase_period train phases. The last phase is
always a test phase.
- If this is a training run with only a train dataset, then x phases = x train
phases.
"""
if not self.test_only:
phases = [
{"train": True}
for _ in range(math.ceil(self.train_phases_per_epoch * self.num_epochs))
]
if self._train_only:
return phases
final_phases = []
for i, phase in enumerate(phases):
final_phases.append(phase)
if (i + 1) % self.test_phase_period == 0:
final_phases.append({"train": False})
if final_phases[-1]["train"]:
final_phases.append({"train": False})
return final_phases
return [{"train": False} for _ in range(self.num_epochs)]
def build_dataloader_from_dataset(self, dataset, **kwargs):
"""Builds a dataloader from the provided dataset
Args:
dataset: A ClassyDataset
kwargs: Additional kwargs to pass during dataloader construction for
derived classes
"""
return dataset.iterator(
phase_type=self.phase_type,
current_phase_id=self.train_phase_idx if self.train else 0,
pin_memory=self.use_gpu and torch.cuda.device_count() > 1,
multiprocessing_context=mp.get_context(self.dataloader_mp_context),
**kwargs,
)
def build_dataloaders_for_current_phase(self):
"""Builds dataloader(s) for the current phase.
Deriving classes can override this method to support custom behavior, like
supporting multiple dataloaders in parallel.
"""
self.dataloader = self.build_dataloader_from_dataset(
self.datasets[self.phase_type]
)
def prepare_optimizer(self, optimizer, model, loss=None):
bn_params, other_params = split_batchnorm_params(model)
if loss is not None:
bn_params_loss, params_loss = split_batchnorm_params(loss)
bn_params = bn_params + bn_params_loss
other_params = other_params + params_loss
bn_schedulers = self.optimizer_schedulers.copy()
if not self.bn_weight_decay:
bn_schedulers["weight_decay"] = 0
param_groups = [{"params": other_params, **self.optimizer_schedulers}]
if len(bn_params) > 0:
param_groups.append({"params": bn_params, **bn_schedulers})
self.optimizer.set_param_groups(param_groups)
def prepare(self):
"""Prepares task for training, populates all derived attributes"""
self.phases = self._build_phases()
self.train = False if self.test_only else self.train
if self.batch_norm_sync_mode == BatchNormSyncMode.PYTORCH:
self.base_model = nn.SyncBatchNorm.convert_sync_batchnorm(self.base_model)
elif self.batch_norm_sync_mode == BatchNormSyncMode.APEX:
sync_bn_process_group = apex.parallel.create_syncbn_process_group(
self.batch_norm_sync_group_size
)
self.base_model = apex.parallel.convert_syncbn_model(
self.base_model, process_group=sync_bn_process_group
)
# move the model and loss to the right device
if self.use_gpu:
self.base_model, self.base_loss = copy_model_to_gpu(
self.base_model, self.base_loss
)
else:
self.base_loss.cpu()
self.base_model.cpu()
if self.optimizer is not None:
self.prepare_optimizer(
optimizer=self.optimizer, model=self.base_model, loss=self.base_loss
)
if self.amp_args is not None:
if self.amp_type == AmpType.APEX:
# Initialize apex.amp. This updates the model and the PyTorch optimizer (
# if training, which is wrapped by the ClassyOptimizer in self.optimizer).
# Please note this must happen before loading the checkpoint, cause
# there's amp state to be restored.
if self.optimizer is None:
self.base_model = apex.amp.initialize(
self.base_model, optimizers=None, **self.amp_args
)
else:
self.base_model, self.optimizer.optimizer = apex.amp.initialize(
self.base_model, self.optimizer.optimizer, **self.amp_args
)
if self.simulated_global_batchsize is not None:
if self.simulated_global_batchsize % self.get_global_batchsize() != 0:
raise ValueError(
f"Global batch size ({self.get_global_batchsize()}) must divide "
f"simulated_global_batchsize ({self.simulated_global_batchsize})"
)
else:
self.simulated_global_batchsize = self.get_global_batchsize()
self.optimizer_period = (
self.simulated_global_batchsize // self.get_global_batchsize()
)
if self.optimizer_period > 1:
logging.info(
f"Using gradient accumulation with a period of {self.optimizer_period}"
)
if self.checkpoint_path:
self.checkpoint_dict = load_and_broadcast_checkpoint(self.checkpoint_path)
classy_state_dict = (
None
if self.checkpoint_dict is None
else self.checkpoint_dict["classy_state_dict"]
)
if classy_state_dict is not None:
state_load_success = update_classy_state(self, classy_state_dict)
assert (
state_load_success
), "Update classy state from checkpoint was unsuccessful."
self.init_distributed_data_parallel_model()
def init_distributed_data_parallel_model(self):
"""
Initialize
`torch.nn.parallel.distributed.DistributedDataParallel <https://pytorch.org/
docs/stable/nn.html#distributeddataparallel>`_.
Needed for distributed training. This is where a model should be wrapped by DDP.
"""
if not is_distributed_training_run():
return
assert (
self.distributed_model is None
), "init_ddp_non_elastic must only be called once"
broadcast_buffers = (
self.broadcast_buffers_mode == BroadcastBuffersMode.FORWARD_PASS
)
if self.use_sharded_ddp:
if not isinstance(self.optimizer, ZeRO):
raise ValueError(
"ShardedDataParallel engine should only be used in conjunction with ZeRO optimizer"
)
from fairscale.nn.data_parallel import ShardedDataParallel
# Replace the original DDP wrap by the shard-aware ShardedDDP
self.distributed_model = ShardedDataParallel(
module=self.base_model,
sharded_optimizer=self.optimizer.optimizer,
broadcast_buffers=broadcast_buffers,
)
else:
self.distributed_model = init_distributed_data_parallel_model(
self.base_model,
broadcast_buffers=broadcast_buffers,
find_unused_parameters=self.find_unused_parameters,
bucket_cap_mb=self.ddp_bucket_cap_mb,
)
if self.fp16_grad_compress:
from torch.distributed.algorithms import ddp_comm_hooks
# FP16 hook is stateless and only takes a process group as the state.
# We use the default process group so we set the state to None.
process_group = None
self.distributed_model.register_comm_hook(
process_group, ddp_comm_hooks.default_hooks.fp16_compress_hook
)
if (
isinstance(self.base_loss, ClassyLoss)
and self.base_loss.has_learned_parameters()
):
logging.info("Initializing distributed loss")
self.distributed_loss = init_distributed_data_parallel_model(
self.base_loss,
broadcast_buffers=broadcast_buffers,
find_unused_parameters=self.find_unused_parameters,
bucket_cap_mb=self.ddp_bucket_cap_mb,
)
@property
def where(self):
"""Returns the proportion of training that has completed. If in test
only mode, returns proportion of testing completed
Returned value is a float in the range [0, 1)
"""
current_step = self.num_updates / self.get_global_batchsize()
num_phases = (
self.get_total_test_phases()
if self.test_only
else self.get_total_training_phases()
)
if self.num_batches_per_phase <= 0:
raise RuntimeError("No batches to read. Is the dataset empty?")
num_steps = num_phases * self.num_batches_per_phase
where = current_step / num_steps
return where
def get_classy_state(self, deep_copy: bool = False):
"""Returns serialiable state of task
Args:
deep_copy: If true, does a deep copy of state before returning.
"""
optimizer_state = {}
if self.optimizer is not None:
optimizer_state = self.optimizer.get_classy_state()
classy_state_dict = {
"train": self.train,
"base_model": self.base_model.get_classy_state(),
"meters": [meter.get_classy_state() for meter in self.meters],
"optimizer": optimizer_state,
"phase_idx": self.phase_idx,
"train_phase_idx": self.train_phase_idx,
"num_updates": self.num_updates,
"losses": self.losses,
"hooks": {hook.name(): hook.get_classy_state() for hook in self.hooks},
"loss": {},
}
if "train" in self.datasets and self._is_checkpointable_dataset(
self.datasets["train"]
):
classy_state_dict["train_dataset_iterator"] = self.datasets[
"train"
].get_classy_state()
if isinstance(self.base_loss, ClassyLoss):
classy_state_dict["loss"] = self.base_loss.get_classy_state()
if self.amp_args is not None:
if self.amp_type == AmpType.APEX:
classy_state_dict["amp"] = apex.amp.state_dict()
elif self.amp_grad_scaler is not None:
classy_state_dict["amp"] = self.amp_grad_scaler.state_dict()
if deep_copy:
classy_state_dict = copy.deepcopy(classy_state_dict)
return classy_state_dict
def set_classy_state(self, state):
"""Set task state
Args:
state: Dict containing state of a task
"""
self.train = False if self.test_only else state["train"]
self.base_model.set_classy_state(state["base_model"])
if self.test_only:
# if we're only testing, just need the state of the model to be updated
return
self.phase_idx = state["phase_idx"]
self.num_updates = state["num_updates"]
self.train_phase_idx = state["train_phase_idx"]
self.losses = state["losses"]
for meter, meter_state in zip(self.meters, state["meters"]):
meter.set_classy_state(meter_state)
if self.optimizer is not None:
self.optimizer.set_classy_state(state["optimizer"])
if state.get("loss") and isinstance(self.base_loss, ClassyLoss):
self.base_loss.set_classy_state(state["loss"])
if "amp" in state:
if self.amp_type == AmpType.APEX:
apex.amp.load_state_dict(state["amp"])
else:
self.amp_grad_scaler.load_state_dict(state["amp"])
for hook in self.hooks:
# we still want to be able to run when new hooks are added or old
# hooks are removed
if hook.name() in state["hooks"]:
hook.set_classy_state(state["hooks"][hook.name()])
else:
logging.warning(f"No state found for hook: {hook.name()}")
if "train" in self.datasets and self._is_checkpointable_dataset(
self.datasets["train"]
):
self.datasets["train"].set_classy_state(state.get("train_dataset_iterator"))
@staticmethod
def _is_checkpointable_dataset(dataset):
return hasattr(dataset, "get_classy_state") and hasattr(
dataset, "set_classy_state"
)
def eval_step(self):
self.last_batch = None
# Process next sample
with Timer() as timer:
sample = next(self.data_iterator)
assert isinstance(sample, dict) and "input" in sample and "target" in sample, (
f"Returned sample [{sample}] is not a map with 'input' and"
+ "'target' keys"
)
target = sample["target"]
if self.use_gpu:
sample = recursive_copy_to_gpu(sample, non_blocking=True)
# Optional Pytorch AMP context
torch_amp_context = (
torch.cuda.amp.autocast()
if self.amp_type == AmpType.PYTORCH
else contextlib.suppress()
)
with torch.no_grad(), torch_amp_context:
output = self.model(sample["input"])
local_loss = self.compute_loss(output, sample)
loss = local_loss.detach().clone()
self.losses.append(loss.data.cpu().item())
self.update_meters(output, sample)
# Move some data to the task so hooks get a chance to access it
self.last_batch = LastBatchInfo(
loss=loss,
output=output,
target=target,
sample=sample,
step_data={"sample_fetch_time": timer.elapsed_time},
)
def check_inf_nan(self, loss):
if loss == float("inf") or loss == float("-inf") or loss != loss:
raise FloatingPointError(f"Loss is infinity or NaN: {loss}")
def _should_do_step(self):
"""Tells if we will be performing an optimizer step.
Returns True always if there is no gradient accumulation. With gradient
accumulation returns True only when the gradients will be synchronized and we
will be performing an optimizer step.
"""
update_idx = self.num_updates // self.get_global_batchsize()
return (update_idx % self.optimizer_period) == self.optimizer_period - 1
def train_step(self):
"""Train step to be executed in train loop."""
self.last_batch = None
# Process next sample
with Timer() as timer:
sample = next(self.data_iterator)
assert isinstance(sample, dict) and "input" in sample and "target" in sample, (
f"Returned sample [{sample}] is not a map with 'input' and"
+ "'target' keys"
)
# Copy sample to GPU
target = sample["target"]
if self.use_gpu:
sample = recursive_copy_to_gpu(sample, non_blocking=True)
if self.mixup_transform is not None:
sample = self.mixup_transform(sample)
# Optional Pytorch AMP context
torch_amp_context = (
torch.cuda.amp.autocast()
if self.amp_type == AmpType.PYTORCH
else contextlib.suppress()
)
# only sync with DDP when we need to perform an optimizer step
# an optimizer step can be skipped if gradient accumulation is enabled
do_step = self._should_do_step()
ctx_mgr_model = (
self.distributed_model.no_sync()
if self.distributed_model is not None and not do_step
else contextlib.suppress()
)
ctx_mgr_loss = (
self.distributed_loss.no_sync()
if self.distributed_loss is not None and not do_step
else contextlib.suppress()
)
with ctx_mgr_model, ctx_mgr_loss:
# Forward pass
with torch.enable_grad(), torch_amp_context:
output = self.compute_model(sample)
local_loss = self.compute_loss(output, sample)
loss = local_loss.detach().clone()
self.losses.append(loss.data.cpu().item())
self.update_meters(output, sample)
# Backwards pass + optimizer step
self.run_optimizer(local_loss)
self.num_updates += self.get_global_batchsize()
# Move some data to the task so hooks get a chance to access it
self.last_batch = LastBatchInfo(
loss=loss,
output=output,
target=target,
sample=sample,
step_data={"sample_fetch_time": timer.elapsed_time},
)
def compute_model(self, sample):
return self.model(sample["input"])
def compute_loss(self, model_output, sample):
return self.loss(model_output, sample["target"])
def run_optimizer(self, loss):
"""Runs backwards pass and update the optimizer"""
self.check_inf_nan(loss)
# Gradient accumulation logic. We always set optimizer_period, even
# if gradient accumulation is disabled. Assumes all batches have the
# same size
update_idx = self.num_updates // self.get_global_batchsize()
do_zero_grad = (update_idx % self.optimizer_period) == 0
do_step = self._should_do_step()
if do_zero_grad:
self.optimizer.zero_grad()
if self.amp_type == AmpType.APEX:
with apex.amp.scale_loss(loss, self.optimizer.optimizer) as scaled_loss:
scaled_loss.backward()
elif self.amp_type == AmpType.PYTORCH:
self.amp_grad_scaler.scale(loss).backward()
else:
loss.backward()
if do_step:
# Handle gradient accumulation related gradient rescaling
if self.optimizer_period != 1:
self._rescale_gradients(1 / self.optimizer_period)
# Clipping must happen after grad accumulation
if self.clip_grad_norm is not None:
self._clip_gradients(self.clip_grad_norm)
if self.amp_type == AmpType.PYTORCH:
# If using mixed precision, handle underflow-related scaling
# See https://pytorch.org/docs/stable/amp.html#gradient-scaling
# for context
self.amp_grad_scaler.step(self.optimizer, where=self.where)
self.amp_grad_scaler.update()
else:
self.optimizer.step(where=self.where)
def _rescale_gradients(self, scale):
for param in master_params(self.optimizer):
if param.grad is not None:
param.grad.data.mul_(scale)
def _clip_gradients(self, max_norm):
nn.utils.clip_grad_norm_(master_params(self.optimizer), max_norm)
def update_meters(self, model_output, sample):
target = sample["target"].detach().cpu()
model_output = model_output.detach().cpu()
# Update meters
for meter in self.meters:
meter.update(model_output, target, is_train=self.train)
def synchronize_losses(self):
"""Average the losses across the different replicas"""
# Average losses across nodes
losses_tensor = torch.tensor(self.losses)
synchronized_losses_tensor = all_reduce_mean(losses_tensor)
self.losses = synchronized_losses_tensor.tolist()
def advance_phase(self):
"""Performs bookkeeping / task updates between phases
Increments phase idx, resets meters, resets loss history,
resets counters, shuffles dataset, rebuilds iterators, and
sets the train / test state for phase.
"""
logging.debug("Advancing phase")
# Reset meters for next phase / epoch
for meter in self.meters:
meter.reset()
# Reset loss history for next epoch
self.losses = []
# Setup new phase
self.phase_idx += 1
phase = self.phases[self.phase_idx]
self.train = True if phase["train"] else False
if self.train:
self.train_phase_idx += 1
# Re-build dataloader & re-create iterator anytime membership changes.
self.build_dataloaders_for_current_phase()
self.create_data_iterators()
# Set up pytorch module in train vs eval mode, update optimizer.
self._set_model_train_mode()
def done_training(self):
"""Stop condition for training"""
return self.phase_idx + 1 >= len(self.phases)
def create_data_iterators(self):
"""Creates data iterator(s) for the current phase."""
# Delete iterator explicitly so that all dataloader processes
# are cleaned up.
del self.data_iterator
self.data_iterator = iter(self.dataloader)
def _set_model_train_mode(self):
"""Set train mode for model"""
phase = self.phases[self.phase_idx]
self.base_model.train(phase["train"])
self.base_loss.train(phase["train"])
if (
self.broadcast_buffers_mode == BroadcastBuffersMode.BEFORE_EVAL
and not self.train
):
self._broadcast_buffers()
def _broadcast_buffers(self):
"""Explicitly synchronize buffers across all devices."""
if self.distributed_model is None:
return
buffers = list(self.base_model.buffers())
if len(buffers) > 0:
logging.info("Synchronizing buffers before evaluation.")
for buffer in buffers:
broadcast(buffer, 0, group=self.distributed_model.process_group)
# TODO: Functions below should be better abstracted into the dataloader
# abstraction
def get_batchsize_per_replica(self):
"""Return local replica's batchsize for dataset (e.g. batchsize per GPU)"""
return self.datasets[self.phase_type].get_batchsize_per_replica()
def get_global_batchsize(self):
"""Return global batchsize across all trainers"""
return self.datasets[self.phase_type].get_global_batchsize()
def on_start(self):
for hook in self.hooks:
hook.on_start(self)
def on_phase_start(self):
self.phase_start_time_total = time.perf_counter()
self.advance_phase()
for hook in self.hooks:
hook.on_phase_start(self)
self.phase_start_time_train = time.perf_counter()
def on_phase_end(self):
self.log_phase_end(self.phase_type)
if self.train:
self.optimizer.on_epoch(where=self.where)
logging.debug("Syncing losses on phase end...")
self.synchronize_losses()
logging.debug("...losses synced")
logging.debug("Syncing meters on phase end...")
for meter in self.meters:
meter.sync_state()
logging.debug("...meters synced")
barrier()
for hook in self.hooks:
hook.on_phase_end(self)
self.perf_log = []
self.log_phase_end(f"{self.phase_type}_total")
if hasattr(self.datasets[self.phase_type], "on_phase_end"):
self.datasets[self.phase_type].on_phase_end()
def on_end(self):
for hook in self.hooks:
hook.on_end(self)
def log_phase_end(self, tag):
start_time = (
self.phase_start_time_train
if tag == self.phase_type
else self.phase_start_time_total
)
phase_duration = time.perf_counter() - start_time
im_per_sec = (
self.get_global_batchsize() * self.num_batches_per_phase
) / phase_duration
self.perf_log.append(
{"tag": tag, "phase_idx": self.train_phase_idx, "im_per_sec": im_per_sec}
)
def __repr__(self):
if hasattr(self, "_config"):
config = json.dumps(self._config, indent=4)
return f"{super().__repr__()} initialized with config:\n{config}"
return super().__repr__()
|
ClassyVision-main
|
classy_vision/tasks/classification_task.py
|
#!/usr/bin/env python3 -u
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
import os
import socket
import subprocess
import sys
import time
from argparse import ArgumentParser, REMAINDER
from contextlib import closing
import ray
class NodeLaunchActor:
"""Ray actor. The code here will run in each node allocated by Ray."""
def run(self, master_addr, master_port, node_rank, dist_world_size, args):
processes = []
# set PyTorch distributed related environmental variables
current_env = os.environ.copy()
current_env["MASTER_ADDR"] = master_addr
current_env["MASTER_PORT"] = str(master_port)
current_env["WORLD_SIZE"] = str(dist_world_size)
if "OMP_NUM_THREADS" not in os.environ and args.nproc_per_node > 1:
current_env["OMP_NUM_THREADS"] = str(1)
print(
"*****************************************\n"
"Setting OMP_NUM_THREADS environment variable for each process "
"to be {} in default, to avoid your system being overloaded, "
"please further tune the variable for optimal performance in "
"your application as needed. \n"
"*****************************************".format(
current_env["OMP_NUM_THREADS"]
)
)
# Set the init_method and rank of the process for distributed training.
for local_rank in range(0, args.nproc_per_node):
# each process's rank
dist_rank = args.nproc_per_node * node_rank + local_rank
current_env["RANK"] = str(dist_rank)
current_env["LOCAL_RANK"] = str(local_rank)
# spawn the processes
with_python = not args.no_python
cmd = []
if with_python:
cmd = [sys.executable, "-u"]
if args.module:
cmd.append("-m")
else:
if not args.use_env:
raise ValueError(
"When using the '--no_python' flag, "
"you must also set the '--use_env' flag."
)
if args.module:
raise ValueError(
"Don't use both the '--no_python' flag"
"and the '--module' flag at the same time."
)
cmd.append(args.training_script)
if not args.use_env:
cmd.append("--local_rank={}".format(local_rank))
cmd.extend(args.training_script_args)
process = subprocess.Popen(cmd, env=current_env)
processes.append(process)
for process in processes:
process.wait()
if process.returncode != 0:
raise subprocess.CalledProcessError(
returncode=process.returncode, cmd=cmd
)
def get_node_ip(self):
return ray.services.get_node_ip_address()
def find_free_port(self):
with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
s.bind(("", 0))
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
return s.getsockname()[1]
def wait_for_gpus(world_size, timeout_secs=3600):
n_gpus = int(ray.cluster_resources().get("GPU", 0))
elapsed_time = 0
while n_gpus < world_size:
logging.warning(
f"Not enough GPUs available ({n_gpus} available,"
f"need {world_size}), waiting 10 seconds"
)
time.sleep(10)
elapsed_time += 10
if elapsed_time > timeout_secs:
raise RuntimeError("Timeout: could not find enough GPUs")
n_gpus = int(ray.cluster_resources().get("GPU", 0))
def parse_args():
"""Helper function parsing the command line options.
@retval ArgumentParser
"""
parser = ArgumentParser(
description="Classy Vision distributed training launch "
"helper utility that will spawn up multiple nodes using Ray"
)
# Optional arguments for the launch helper
parser.add_argument(
"--nnodes",
type=int,
default=1,
help="The number of nodes to use for distributed training",
)
parser.add_argument(
"--nproc_per_node",
type=int,
default=1,
help="The number of processes to launch on each node, "
"for GPU training, this is recommended to be set "
"to the number of GPUs in your system so that "
"each process can be bound to a single GPU.",
)
parser.add_argument(
"--use_env",
default=False,
action="store_true",
help="Use environment variable to pass "
"'local rank'."
"If set to True, the script will not pass "
"--local_rank as argument, and will instead set LOCAL_RANK.",
)
parser.add_argument(
"-m",
"--module",
default=False,
action="store_true",
help="Changes each process to interpret the launch script "
"as a python module, executing with the same behavior as"
"'python -m'.",
)
parser.add_argument(
"--no_python",
default=False,
action="store_true",
help='Do not prepend the training script with "python" - just exec '
"it directly. Useful when the script is not a Python script.",
)
# Ray-related arguments
group = parser.add_argument_group("Ray related arguments")
group.add_argument("--ray-address", default="auto", type=str)
# positional
parser.add_argument(
"training_script",
type=str,
help="The full path to the single GPU training "
"program/script to be launched in parallel, "
"followed by all the arguments for the "
"training script",
)
# rest from the training program
parser.add_argument("training_script_args", nargs=REMAINDER)
return parser.parse_args()
def main():
args = parse_args()
ray.init(address=args.ray_address)
# world size in terms of number of processes
dist_world_size = args.nproc_per_node * args.nnodes
wait_for_gpus(dist_world_size)
# Set up Ray distributed actors.
actor = ray.remote(num_cpus=1, num_gpus=args.nproc_per_node)(NodeLaunchActor)
workers = [actor.remote() for i in range(args.nnodes)]
# Set worker 0 as the master
master_addr = ray.get(workers[0].get_node_ip.remote())
master_port = ray.get(workers[0].find_free_port.remote())
unfinished = [
worker.run.remote(
master_addr=master_addr,
master_port=master_port,
node_rank=i,
dist_world_size=dist_world_size,
args=args,
)
for i, worker in enumerate(workers)
]
try:
while len(unfinished) > 0:
finished, unfinished = ray.wait(unfinished)
finished = ray.get(finished)
except Exception as inst:
logging.exception("An error occurred:")
ray.shutdown()
if __name__ == "__main__":
main()
|
ClassyVision-main
|
classy_vision/distributed/launch_ray.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
|
ClassyVision-main
|
classy_vision/distributed/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
from typing import Any, Callable, Dict, Optional
import torch
from torchvision.datasets.hmdb51 import HMDB51
from . import register_dataset
from .classy_video_dataset import ClassyVideoDataset
from .transforms.util_video import build_video_field_transform_default
@register_dataset("hmdb51")
class HMDB51Dataset(ClassyVideoDataset):
"""`HMDB51 <http://serre-lab.clps.brown.edu/resource/
hmdb-a-large-human-motion-database/>`_ is an action recognition video dataset,
and it has 51 classes.
It is built on top of `HMDB51 <https://github.com/pytorch/vision/blob/
master/torchvision/datasets/hmdb51.py#L10/>`_ dataset class in TorchVision.
"""
def __init__(
self,
split: str,
batchsize_per_replica: int,
shuffle: bool,
transform: Callable,
num_samples: Optional[int],
frames_per_clip: int,
video_width: int,
video_height: int,
video_min_dimension: int,
audio_samples: int,
step_between_clips: int,
frame_rate: Optional[int],
clips_per_video: int,
video_dir: str,
splits_dir: str,
fold: int,
metadata_filepath: str,
):
"""The constructor of HMDB51Dataset.
Args:
split: dataset split which can be either "train" or "test"
batchsize_per_replica: batch size per model replica
shuffle: If true, shuffle the dataset
transform: a dict where transforms video and audio data
num_samples: if not None, it will subsample dataset
frames_per_clip: the number of frames in a video clip
video_width: rescaled video width. If 0, keep original width
video_height: rescaled video height. If 0, keep original height
video_min_dimension: rescale video so that min(height, width) =
``video_min_dimension``. If 0, keep original video resolution.
Note only one of (``video_width``, ``video_height``) and
(``video_min_dimension``) can be set
audio_samples: desired audio sample rate. If 0, keep original
audio sample rate.
step_between_clips: Number of frames between each clip.
frame_rate: desired video frame rate. If None, keep
orignal video frame rate.
clips_per_video: Number of clips to sample from each video
video_dir: path to video folder
splits_dir: path to dataset splitting file folder
fold: HMDB51 dataset has 3 folds. Valid values are 1, 2 and 3.
metadata_filepath: path to the dataset meta data
"""
# dataset metadata includes the path of video file, the pts of frames in
# the video and other meta info such as video fps, duration, audio sample rate.
# Users do not need to know the details of metadata. The computing, loading
# and saving logic of metata are all handled inside of the dataset.
# Given the "metadata_file" path, if such file exists, we load it as meta data.
# Otherwise, we compute the meta data, and save it at "metadata_file" path.
metadata = None
if os.path.exists(metadata_filepath):
metadata = HMDB51Dataset.load_metadata(
metadata_filepath, video_dir=video_dir, update_file_path=True
)
dataset = HMDB51(
video_dir,
splits_dir,
frames_per_clip,
step_between_clips=step_between_clips,
frame_rate=frame_rate,
_precomputed_metadata=metadata,
fold=fold,
train=(split == "train"),
num_workers=torch.get_num_threads() // 2, # heuristically use half threads
_video_width=video_width,
_video_height=video_height,
_video_min_dimension=video_min_dimension,
_audio_samples=audio_samples,
)
metadata = dataset.metadata
if metadata and not os.path.exists(metadata_filepath):
HMDB51Dataset.save_metadata(metadata, metadata_filepath)
super().__init__(
dataset,
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
clips_per_video,
)
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "HMDB51Dataset":
"""Instantiates a HMDB51Dataset from a configuration.
Args:
config: A configuration for a HMDB51Dataset.
See :func:`__init__` for parameters expected in the config.
Returns:
A HMDB51Dataset instance.
"""
required_args = ["split", "metadata_file", "video_dir", "splits_dir"]
assert all(
arg in config for arg in required_args
), f"The arguments {required_args} are all required."
split = config["split"]
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
step_between_clips,
frame_rate,
clips_per_video,
) = cls.parse_config(config)
transform = build_video_field_transform_default(transform_config, split)
return cls(
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
step_between_clips,
frame_rate,
clips_per_video,
config["video_dir"],
config["splits_dir"],
config["fold"]
if "fold" in config
else 1, # HMDB51 has 3 folds. Use fold 1 by default
config["metadata_file"],
)
|
ClassyVision-main
|
classy_vision/dataset/classy_hmdb51.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from abc import ABC, abstractmethod
from typing import Any, Iterable, Iterator
class DataloaderWrapper(ABC):
"""
Abstract class representing dataloader which wraps another dataloader.
Attribute accesses are passed to the wrapped dataloader.
"""
def __init__(self, dataloader: Iterable) -> None:
# we use self.__dict__ to set the attributes since the __setattr__ method
# is overridden
attributes = {"dataloader": dataloader, "_iter": None}
self.__dict__.update(attributes)
@abstractmethod
def __iter__(self) -> Iterator[Any]:
pass
@abstractmethod
def __next__(self) -> Any:
pass
def __getattr__(self, attr) -> Any:
"""
Pass the getattr call to the wrapped dataloader
"""
if attr in self.__dict__:
return self.__dict__[attr]
return getattr(self.dataloader, attr)
def __setattr__(self, attr, value) -> None:
"""
Pass the setattr call to the wrapped dataloader
"""
if attr in self.__dict__:
self.__dict__[attr] = value
else:
setattr(self.dataloader, attr, value)
|
ClassyVision-main
|
classy_vision/dataset/dataloader_wrapper.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Callable, Dict, Optional, Union
from classy_vision.dataset import ClassyDataset, register_dataset
from classy_vision.dataset.transforms import build_transforms, ClassyTransform
from torchvision.datasets.cifar import CIFAR10, CIFAR100
class CIFARDataset(ClassyDataset):
_CIFAR_TYPE = None
def __init__(
self,
split: Optional[str],
batchsize_per_replica: int,
shuffle: bool,
transform: Optional[Union[ClassyTransform, Callable]],
num_samples: Optional[int],
root: str,
download: bool = None,
):
assert self._CIFAR_TYPE in [
"cifar10",
"cifar100",
], "CIFARDataset must be subclassed and a valid _CIFAR_TYPE provided"
if self._CIFAR_TYPE == "cifar10":
dataset = CIFAR10(root=root, train=(split == "train"), download=download)
if self._CIFAR_TYPE == "cifar100":
dataset = CIFAR100(root=root, train=(split == "train"), download=download)
super().__init__(
dataset, batchsize_per_replica, shuffle, transform, num_samples
)
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "CIFARDataset":
"""Instantiates a CIFARDataset from a configuration.
Args:
config: A configuration for a CIFARDataset.
See :func:`__init__` for parameters expected in the config.
Returns:
A CIFARDataset instance.
"""
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
) = cls.parse_config(config)
split = config.get("split")
root = config.get("root")
download = config.get("download")
transform = build_transforms(transform_config)
return cls(
split=split,
batchsize_per_replica=batchsize_per_replica,
shuffle=shuffle,
transform=transform,
num_samples=num_samples,
root=root,
download=download,
)
@register_dataset("classy_cifar10")
class CIFAR10Dataset(CIFARDataset):
_CIFAR_TYPE = "cifar10"
@register_dataset("classy_cifar100")
class CIFAR100Dataset(CIFARDataset):
_CIFAR_TYPE = "cifar100"
|
ClassyVision-main
|
classy_vision/dataset/classy_cifar.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os.path
from typing import Any, Callable, Dict, List, Optional, Union
from torchvision import datasets, transforms
from . import ClassyDataset, register_dataset
from .core import ListDataset
from .transforms import build_transforms, ClassyTransform, TupleToMapTransform
def _is_torchvision_imagefolder(image_folder):
with os.scandir(image_folder) as folder_iter:
try:
dir_entry = next(folder_iter)
return dir_entry.is_dir()
except StopIteration:
raise OSError(f"Image folder {image_folder} is empty")
def _get_image_paths(image_folder):
return [f"{image_folder}/{file}" for file in os.listdir(image_folder)]
def _load_dataset(image_folder, image_files):
if image_folder is not None:
if _is_torchvision_imagefolder(image_folder):
return (
datasets.ImageFolder(image_folder),
TupleToMapTransform(list_of_map_keys=["input", "target"]),
)
else:
image_files = _get_image_paths(image_folder)
return ListDataset(image_files, metadata=None), None
@register_dataset("image_path")
class ImagePathDataset(ClassyDataset):
"""Dataset which reads images from a local filesystem. Implements ClassyDataset."""
def __init__(
self,
batchsize_per_replica: int,
shuffle: bool,
transform: Optional[Union[ClassyTransform, Callable]] = None,
num_samples: Optional[int] = None,
image_folder: Optional[str] = None,
image_files: Optional[List[str]] = None,
):
"""Constructor for ImagePathDataset.
Only one of image_folder or image_files should be passed to specify the images.
Args:
batchsize_per_replica: Positive integer indicating batch size for each
replica
shuffle: Whether we should shuffle between epochs
transform: Transform to be applied to each sample
num_samples: When set, this restricts the number of samples provided by
the dataset
image_folder: A directory with one of the following structures -
- A directory containing sub-directories with images for each target,
which is the format expected by
:class:`torchvision.datasets.ImageFolder` -
dog/xxx.png
dog/xxy.png
cat/123.png
cat/nsdf3.png
In this case, the targets are inferred from the sub-directories.
- A directory containing images -
123.png
xyz.png
In this case, the targets are not returned (useful for inference).
image_files: A list of image files -
[
"123.png",
"dog/xyz.png",
"/home/cat/aaa.png"
]
In this case, the targets are not returned (useful for inference).
"""
if (image_folder is None) == (image_files is None):
raise ValueError("One of image_folder and image_files should be provided")
dataset, preproc_transform = _load_dataset(image_folder, image_files)
super().__init__(
dataset, batchsize_per_replica, shuffle, transform, num_samples
)
# Some of the base datasets from _load_dataset have different
# sample formats, the preproc_transform should map them all to
# the dict {"input": img, "target": label} format
if preproc_transform is not None:
self.transform = transforms.Compose([preproc_transform, self.transform])
@classmethod
def from_config(cls, config: Dict[str, Any]):
"""Instantiates ImagePathDataset from a config.
Args:
config: A configuration for ImagePathDataset.
See :func:`__init__` for parameters expected in the config.
Returns:
An ImagePathDataset instance.
"""
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
) = cls.parse_config(config)
transform = build_transforms(transform_config)
return cls(
batchsize_per_replica,
shuffle,
transform,
num_samples,
image_folder=config.get("image_folder"),
image_files=config.get("image_files"),
)
|
ClassyVision-main
|
classy_vision/dataset/image_path_dataset.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
from typing import Any, Callable, Dict, List, Optional
import torch
from torchvision.datasets.kinetics import Kinetics
from . import register_dataset
from .classy_video_dataset import ClassyVideoDataset
from .transforms.util_video import build_video_field_transform_default
@register_dataset("kinetics400")
class Kinetics400Dataset(ClassyVideoDataset):
"""`Kinetics-400 <https://deepmind.com/research/open-source/
open-source-datasets/kinetics/>`_ is an action recognition video dataset,
and it has 400 classes.
`Original publication <https://arxiv.org/pdf/1705.06950.pdf>`_
We assume videos are already trimmed to 10-second clip, and are stored in a
folder.
It is built on top of `Kinetics <https://github.com/pytorch/vision/blob/
master/torchvision/datasets/kinetics.py#L7/>`_ dataset class in TorchVision.
"""
def __init__(
self,
split: str,
batchsize_per_replica: int,
shuffle: bool,
transform: Callable,
num_samples: Optional[int],
frames_per_clip: int,
video_width: int,
video_height: int,
video_min_dimension: int,
audio_samples: int,
audio_channels: int,
step_between_clips: int,
frame_rate: Optional[int],
clips_per_video: int,
video_dir: str,
extensions: List[str],
metadata_filepath: str,
):
"""The constructor of Kinetics400Dataset.
Args:
split: dataset split which can be either "train" or "test"
batchsize_per_replica: batch size per model replica
shuffle: If true, shuffle the dataset
transform: a dict where transforms video and audio data
num_samples: if provided, it will subsample dataset
frames_per_clip: the No. of frames in a video clip
video_width: rescaled video width. If 0, keep original width
video_height: rescaled video height. If 0, keep original height
video_min_dimension: rescale video so that min(height, width) =
video_min_dimension. If 0, keep original video resolution. Note
only one of (video_width, video_height) and (video_min_dimension)
can be set
audio_samples: desired audio sample rate. If 0, keep original
audio sample rate
audio_channels: desire No. of audio channel. If 0, keep original audio
channels
step_between_clips: Number of frames between each clip.
frame_rate: desired video frame rate. If None, keep
orignal video frame rate.
clips_per_video: Number of clips to sample from each video
video_dir: path to video folder
extensions: A list of file extensions, such as "avi" and "mp4". Only
video matching those file extensions are added to the dataset
metadata_filepath: path to the dataset meta data
"""
# dataset metadata includes the path of video file, the pts of frames in
# the video and other meta info such as video fps, duration, audio sample rate.
# Users do not need to know the details of metadata. The computing, loading
# and saving logic of metata are all handled inside of the dataset.
# Given the "metadata_file" path, if such file exists, we load it as meta data.
# Otherwise, we compute the meta data, and save it at "metadata_file" path.
metadata = None
if os.path.exists(metadata_filepath):
metadata = Kinetics400Dataset.load_metadata(
metadata_filepath, video_dir=video_dir, update_file_path=True
)
dataset = Kinetics(
video_dir,
frames_per_clip,
num_classes="400",
step_between_clips=step_between_clips,
frame_rate=frame_rate,
_precomputed_metadata=metadata,
extensions=extensions,
num_workers=torch.get_num_threads() // 2, # heuristically use half threads
_video_width=video_width,
_video_height=video_height,
_video_min_dimension=video_min_dimension,
_audio_samples=audio_samples,
_audio_channels=audio_channels,
_legacy=True,
)
metadata = dataset.metadata
if metadata and not os.path.exists(metadata_filepath):
Kinetics400Dataset.save_metadata(metadata, metadata_filepath)
super().__init__(
dataset,
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
clips_per_video,
)
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "Kinetics400Dataset":
"""Instantiates a Kinetics400Dataset from a configuration.
Args:
config: A configuration for a Kinetics400Dataset.
See :func:`__init__` for parameters expected in the config.
Returns:
A Kinetics400Dataset instance.
"""
required_args = ["split", "metadata_file", "video_dir"]
assert all(
arg in config for arg in required_args
), f"The arguments {required_args} are all required."
split = config["split"]
audio_channels = config.get("audio_channels", 0)
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
step_between_clips,
frame_rate,
clips_per_video,
) = cls.parse_config(config)
extensions = config.get("extensions", ("mp4"))
transform = build_video_field_transform_default(transform_config, split)
return cls(
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
audio_channels,
step_between_clips,
frame_rate,
clips_per_video,
config["video_dir"],
extensions,
config["metadata_file"],
)
|
ClassyVision-main
|
classy_vision/dataset/classy_kinetics400.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Callable, Dict
from classy_vision.generic.distributed_util import get_rank, get_world_size
from torch.utils.data.distributed import DistributedSampler
from . import register_dataset
from .classy_video_dataset import ClassyVideoDataset
from .core import RandomVideoDataset
from .transforms.util_video import build_video_field_transform_default
@register_dataset("synthetic_video")
class SyntheticVideoDataset(ClassyVideoDataset):
"""Classy Dataset which produces random synthetic video clips.
Useful for testing since the dataset is much faster to initialize and fetch samples
from, compared to real world datasets.
Note: Unlike :class:`SyntheticImageDataset`, this dataset generates targets
randomly, independent of the video clips.
"""
def __init__(
self,
num_classes: int,
split: str,
batchsize_per_replica: int,
shuffle: bool,
transform: Callable,
num_samples: int,
frames_per_clip: int,
video_width: int,
video_height: int,
audio_samples: int,
clips_per_video: int,
):
"""The constructor of SyntheticVideoDataset.
Args:
num_classes: Number of classes in the generated targets.
split: Split of dataset to use
batchsize_per_replica: batch size per model replica
shuffle: Whether we should shuffle between epochs
transform: Transform to be applied to each sample
num_samples: Number of samples to return
frames_per_clip: Number of frames in a video clip
video_width: Width of the video clip
video_height: Height of the video clip
audio_samples: Audio sample rate
clips_per_video: Number of clips per video
"""
dataset = RandomVideoDataset(
num_classes,
split,
num_samples,
frames_per_clip,
video_width,
video_height,
audio_samples,
clips_per_video,
)
super().__init__(
dataset,
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
clips_per_video,
)
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "SyntheticVideoDataset":
"""Instantiates a SyntheticVideoDataset from a configuration.
Args:
config: A configuration for a SyntheticVideoDataset.
See :func:`__init__` for parameters expected in the config.
Returns:
A SyntheticVideoDataset instance.
"""
split = config["split"]
num_classes = config["num_classes"]
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
frames_per_clip,
video_width,
video_height,
video_min_dimension,
audio_samples,
step_between_clips,
frame_rate,
clips_per_video,
) = cls.parse_config(config)
transform = build_video_field_transform_default(transform_config, split)
return cls(
num_classes,
split,
batchsize_per_replica,
shuffle,
transform,
num_samples,
frames_per_clip,
video_width,
video_height,
audio_samples,
clips_per_video,
)
@property
def video_clips(self):
raise NotImplementedError()
def _get_sampler(self, epoch):
world_size = get_world_size()
rank = get_rank()
sampler = DistributedSampler(
self, num_replicas=world_size, rank=rank, shuffle=self.shuffle
)
sampler.set_epoch(epoch)
return sampler
|
ClassyVision-main
|
classy_vision/dataset/classy_synthetic_video.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import traceback
from pathlib import Path
from classy_vision.generic.registry_utils import import_all_modules
from .classy_dataset import ClassyDataset
FILE_ROOT = Path(__file__).parent
DATASET_REGISTRY = {}
DATASET_REGISTRY_TB = {}
DATASET_CLASS_NAMES = set()
DATASET_CLASS_NAMES_TB = {}
def build_dataset(config, *args, **kwargs):
"""Builds a :class:`ClassyDataset` from a config.
This assumes a 'name' key in the config which is used to determine what
dataset class to instantiate. For instance, a config `{"name": "my_dataset",
"folder": "/data"}` will find a class that was registered as "my_dataset"
(see :func:`register_dataset`) and call .from_config on it."""
dataset = DATASET_REGISTRY[config["name"]].from_config(config, *args, **kwargs)
num_workers = config.get("num_workers")
if num_workers is not None:
dataset.set_num_workers(num_workers)
return dataset
def register_dataset(name, bypass_checks=False):
"""Registers a :class:`ClassyDataset` subclass.
This decorator allows Classy Vision to instantiate a subclass of
ClassyDataset from a configuration file, even if the class itself is not
part of the Classy Vision framework. To use it, apply this decorator to a
ClassyDataset subclass like this:
.. code-block:: python
@register_dataset("my_dataset")
class MyDataset(ClassyDataset):
...
To instantiate a dataset from a configuration file, see
:func:`build_dataset`."""
def register_dataset_cls(cls):
if not bypass_checks:
if name in DATASET_REGISTRY:
msg = "Cannot register duplicate dataset ({}). Already registered at \n{}\n"
raise ValueError(msg.format(name, DATASET_REGISTRY_TB[name]))
if not issubclass(cls, ClassyDataset):
raise ValueError(
"Dataset ({}: {}) must extend ClassyDataset".format(
name, cls.__name__
)
)
if cls.__name__ in DATASET_CLASS_NAMES:
msg = (
"Cannot register dataset with duplicate class name({})."
+ "Previously registered at \n{}\n"
)
raise ValueError(
msg.format(cls.__name__, DATASET_CLASS_NAMES_TB[cls.__name__])
)
tb = "".join(traceback.format_stack())
DATASET_REGISTRY[name] = cls
DATASET_CLASS_NAMES.add(cls.__name__)
DATASET_REGISTRY_TB[name] = tb
DATASET_CLASS_NAMES_TB[cls.__name__] = tb
return cls
return register_dataset_cls
# automatically import any Python files in the dataset/ directory
import_all_modules(FILE_ROOT, "classy_vision.dataset")
from .classy_cifar import CIFARDataset # isort:skip
from .classy_hmdb51 import HMDB51Dataset # isort:skip
from .classy_kinetics400 import Kinetics400Dataset # isort:skip
from .classy_synthetic_image import SyntheticImageDataset # isort:skip
from .classy_synthetic_image_streaming import ( # isort:skip
SyntheticImageStreamingDataset, # isort:skip
) # isort:skip
from .classy_synthetic_video import SyntheticVideoDataset # isort:skip
from .classy_ucf101 import UCF101Dataset # isort:skip
from .classy_video_dataset import ClassyVideoDataset # isort:skip
from .dataloader_async_gpu_wrapper import DataloaderAsyncGPUWrapper # isort:skip
from .dataloader_limit_wrapper import DataloaderLimitWrapper # isort:skip
from .dataloader_skip_none_wrapper import DataloaderSkipNoneWrapper # isort:skip
from .dataloader_wrapper import DataloaderWrapper # isort:skip
from .image_path_dataset import ImagePathDataset # isort:skip
__all__ = [
"CIFARDataset",
"ClassyDataset",
"ClassyVideoDataset",
"DataloaderLimitWrapper",
"DataloaderSkipNoneWrapper",
"DataloaderWrapper",
"DataloaderAsyncGPUWrapper",
"HMDB51Dataset",
"ImagePathDataset",
"Kinetics400Dataset",
"SyntheticImageDataset",
"SyntheticImageStreamingDataset",
"SyntheticVideoDataset",
"UCF101Dataset",
"build_dataset",
"register_dataset",
]
|
ClassyVision-main
|
classy_vision/dataset/__init__.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torchvision.transforms as transforms
from classy_vision.dataset import register_dataset
from classy_vision.dataset.classy_dataset import ClassyDataset
from classy_vision.dataset.core import RandomImageBinaryClassDataset
from classy_vision.dataset.dataloader_async_gpu_wrapper import DataloaderAsyncGPUWrapper
from classy_vision.dataset.dataloader_limit_wrapper import DataloaderLimitWrapper
from classy_vision.dataset.transforms.util import (
build_field_transform_default_imagenet,
ImagenetConstants,
)
@register_dataset("synthetic_image_streaming")
class SyntheticImageStreamingDataset(ClassyDataset):
"""
Synthetic image dataset that behaves like a streaming dataset.
Requires a "num_samples" argument which decides the number of samples in the
phase. Also takes an optional "length" input which sets the length of the
dataset.
"""
def __init__(
self,
batchsize_per_replica,
shuffle,
transform,
num_samples,
crop_size,
class_ratio,
seed,
length=None,
async_gpu_copy: bool = False,
):
if length is None:
# If length not provided, set to be same as num_samples
length = num_samples
dataset = RandomImageBinaryClassDataset(crop_size, class_ratio, length, seed)
super().__init__(
dataset, batchsize_per_replica, shuffle, transform, num_samples
)
self.async_gpu_copy = async_gpu_copy
@classmethod
def from_config(cls, config):
# Parse the config
assert all(key in config for key in ["crop_size", "class_ratio", "seed"])
length = config.get("length")
crop_size = config["crop_size"]
class_ratio = config["class_ratio"]
seed = config["seed"]
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
) = cls.parse_config(config)
async_gpu_copy = config.get("async_gpu_copy", False)
# Build the transforms
default_transform = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize(
mean=ImagenetConstants.MEAN, std=ImagenetConstants.STD
),
]
)
transform = build_field_transform_default_imagenet(
transform_config, default_transform=default_transform
)
return cls(
batchsize_per_replica,
shuffle,
transform,
num_samples,
crop_size,
class_ratio,
seed,
length=length,
async_gpu_copy=async_gpu_copy,
)
def iterator(self, *args, **kwargs):
dataloader = DataloaderLimitWrapper(
super().iterator(*args, **kwargs),
self.num_samples // self.get_global_batchsize(),
)
if self.async_gpu_copy:
dataloader = DataloaderAsyncGPUWrapper(dataloader)
return dataloader
|
ClassyVision-main
|
classy_vision/dataset/classy_synthetic_image_streaming.py
|
#!/usr/bin/env python3
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
from typing import Any, Callable, Dict, List, Optional
import torchvision.transforms as transforms
from . import register_dataset
from .classy_dataset import ClassyDataset
from .core import RandomImageBinaryClassDataset
from .transforms import build_transforms
from .transforms.util import build_field_transform_default_imagenet, ImagenetConstants
@register_dataset("synthetic_image")
class SyntheticImageDataset(ClassyDataset):
"""Classy Dataset which produces random synthetic images with binary targets.
The underlying dataset sets targets based on the channels in the image, so users can
validate their setup by checking if they can get 100% accuracy on this dataset.
Useful for testing since the dataset is much faster to initialize and fetch samples
from, compared to real world datasets.
"""
def __init__(
self,
batchsize_per_replica: int,
shuffle: bool,
transform: Optional[Callable],
num_samples: int,
crop_size: int,
class_ratio: float,
seed: int,
) -> None:
"""
Args:
batchsize_per_replica: Positive integer indicating batch size for each
replica
shuffle: Whether we should shuffle between epochs
transform: When specified, transform to be applied to each sample
num_samples: Number of samples to return
crop_size: Image size, used for both height and width
class_ratio: Ratio of the distribution of target classes
seed: Seed used for image generation. Use the same seed to generate the same
set of samples.
split: When specified, split of dataset to use
"""
dataset = RandomImageBinaryClassDataset(
crop_size, class_ratio, num_samples, seed
)
super().__init__(
dataset, batchsize_per_replica, shuffle, transform, num_samples
)
@classmethod
def from_config(cls, config: Dict[str, Any]) -> "SyntheticImageDataset":
"""Instantiates a SyntheticImageDataset from a configuration.
Args:
config: A configuration for a SyntheticImageDataset.
See :func:`__init__` for parameters expected in the config.
Returns:
A SyntheticImageDataset instance.
"""
assert all(key in config for key in ["crop_size", "class_ratio", "seed"])
crop_size = config["crop_size"]
class_ratio = config["class_ratio"]
seed = config["seed"]
(
transform_config,
batchsize_per_replica,
shuffle,
num_samples,
) = cls.parse_config(config)
try:
transform = build_transforms(transform_config)
except Exception:
logging.error(
"We recently changed transform behavior"
" do you need to update your config?"
" See resnet50_synthetic_image_classy_config.json"
" as an example."
)
raise
return cls(
batchsize_per_replica,
shuffle,
transform,
num_samples,
crop_size,
class_ratio,
seed,
)
|
ClassyVision-main
|
classy_vision/dataset/classy_synthetic_image.py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.