def test_deep_copy(self):
config = {
"name": "label_smoothing_cross_entropy",
"ignore_index": -1,
"smoothing_param": 0.5,
}
crit = build_loss(config)
self.assertTrue(isinstance(crit, LabelSmoothingCrossEntropyLoss))
outputs = torch.tensor([[0.0, 7.0, 0.0, 0.0, 2.0]])
targets = torch.tensor([[0, 0, 0, 0, 1]])
crit(outputs, targets)
crit2 = copy.deepcopy(crit)
self.assertAlmostEqual(crit2(outputs, targets).item(),
5.07609558,
places=5)
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:
self.assertAlmostEqual(
crit(output, torch.tensor([-1])).item(), 0.0)
def _build_task(self, num_epochs, skip_param_schedulers=False):
config = self._get_config(skip_param_schedulers)
config["optimizer"]["num_epochs"] = num_epochs
task = (
ClassificationTask()
.set_num_epochs(num_epochs)
.set_loss(build_loss(config["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)
self.assertTrue(task is not None)
return task
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.
"""
optimizer_config = config["optimizer"]
optimizer_config["num_epochs"] = config["num_epochs"]
datasets = {}
phase_types = ["train", "test"]
for phase_type in phase_types:
datasets[phase_type] = build_dataset(config["dataset"][phase_type])
loss = build_loss(config["loss"])
test_only = config.get("test_only", False)
amp_opt_level = config.get("amp_opt_level")
meters = build_meters(config.get("meters", {}))
model = build_model(config["model"])
# put model in eval mode in case any hooks modify model states, it'll
# be reset to train mode before training
model.eval()
optimizer = build_optimizer(optimizer_config)
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_optimizer(optimizer)
.set_meters(meters)
.set_amp_opt_level(amp_opt_level)
.set_distributed_options(
BroadcastBuffersMode[config.get("broadcast_buffers", "DISABLED")]
)
)
for phase_type in phase_types:
task.set_dataset(datasets[phase_type], phase_type)
return task
def test_smoothing_all_ones_one_hot_targets(self):
config = {
"name": "label_smoothing_cross_entropy",
"ignore_index": -1,
"smoothing_param": 0.1,
}
crit = build_loss(config)
targets = torch.tensor([[1, 1, 1, 1]])
self.assertTrue(isinstance(crit, LabelSmoothingCrossEntropyLoss))
valid_targets = crit.compute_valid_targets(targets, 4)
self.assertTrue(
torch.allclose(valid_targets, torch.tensor([[1.0, 1.0, 1.0, 1.0]]))
)
smoothed_targets = crit.smooth_targets(valid_targets, 4)
self.assertTrue(
torch.allclose(smoothed_targets, torch.tensor([[0.25, 0.25, 0.25, 0.25]]))
)
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_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_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)
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.
"""
optimizer_config = config["optimizer"]
optimizer_config["num_epochs"] = config["num_epochs"]
datasets = {}
phase_types = ["train", "test"]
for phase_type in phase_types:
datasets[phase_type] = build_dataset(config["dataset"][phase_type])
loss = build_loss(config["loss"])
test_only = config.get("test_only", False)
amp_args = config.get("amp_args")
meters = build_meters(config.get("meters", {}))
model = build_model(config["model"])
optimizer = build_optimizer(optimizer_config)
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_optimizer(optimizer).set_meters(
meters).set_amp_args(amp_args).set_distributed_options(
broadcast_buffers_mode=BroadcastBuffersMode[config.get(
"broadcast_buffers", "disabled").upper()],
batch_norm_sync_mode=BatchNormSyncMode[config.get(
"batch_norm_sync_mode", "disabled").upper()],
))
for phase_type in phase_types:
task.set_dataset(datasets[phase_type], phase_type)
return task
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 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"], config["mixup"].get("num_classes"))
# 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", True),
}
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)))
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
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.
"""
optimizer_config = config["optimizer"]
# TODO Make distinction between epochs and phases in optimizer clear
train_phases_per_epoch = config["dataset"]["train"].get(
"phases_per_epoch", 1)
optimizer_config[
"num_epochs"] = config["num_epochs"] * train_phases_per_epoch
datasets = {}
phase_types = ["train", "test"]
for phase_type in phase_types:
datasets[phase_type] = build_dataset(config["dataset"][phase_type])
loss = build_loss(config["loss"])
test_only = config.get("test_only", False)
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"], config["mixup"].get("num_classes"))
# hooks config is optional
hooks_config = config.get("hooks")
hooks = []
if hooks_config is not None:
hooks = build_hooks(hooks_config)
optimizer = build_optimizer(optimizer_config)
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_optimizer(optimizer).set_meters(
meters).set_amp_args(amp_args).
set_mixup_transform(mixup_transform).set_distributed_options(
broadcast_buffers_mode=BroadcastBuffersMode[config.get(
"broadcast_buffers", "disabled").upper()],
batch_norm_sync_mode=BatchNormSyncMode[config.get(
"batch_norm_sync_mode", "disabled").upper()],
find_unused_parameters=config.get("find_unused_parameters",
True),
).set_hooks(hooks))
use_gpu = config.get("use_gpu")
if use_gpu is not None:
task.set_use_gpu(use_gpu)
for phase_type in phase_types:
task.set_dataset(datasets[phase_type], phase_type)
return task
def main():
args = parser.parse_args()
print(args)
args.cuda = not args.no_cuda and torch.cuda.is_available()
if args.cuda and args.mkldnn:
assert False, "We can not runing this work on GPU backend and MKLDNN backend \
please set one backend.\n"
if args.cuda:
print("Using GPU backend to do this work.\n")
elif args.mkldnn:
print("Using MKLDNN backend to do this work.\n")
else:
print("Using native CPU backend to do this work.\n")
# set it to the folder where video files are saved
video_dir = args.video_dir + "/UCF-101"
# set it to the folder where dataset splitting files are saved
splits_dir = args.video_dir + "/ucfTrainTestlist"
# set it to the file path for saving the metadata
metadata_file = args.video_dir + "/metadata.pth"
resnext3d_configs =model_config.ResNeXt3D_Config(video_dir, splits_dir, metadata_file, args.num_epochs)
resnext3d_configs.setUp()
datasets = {}
dataset_train_configs = resnext3d_configs.dataset_configs["train"]
dataset_test_configs = resnext3d_configs.dataset_configs["test"]
dataset_train_configs["batchsize_per_replica"] = args.batch_size_train
# For testing, batchsize per replica should be equal to clips_per_video
dataset_test_configs["batchsize_per_replica"] = args.batch_size_eval
dataset_test_configs["clips_per_video"] = args.batch_size_eval
datasets["train"] = build_dataset(dataset_train_configs)
datasets["test"] = build_dataset(dataset_test_configs)
model = build_model(resnext3d_configs.model_configs)
meters = build_meters(resnext3d_configs.meters_configs)
loss = build_loss({"name": "CrossEntropyLoss"})
optimizer = build_optimizer(resnext3d_configs.optimizer_configs)
# there some ops are not supported by MKLDNN, so convert input to CPU tensor
if args.mkldnn:
heads_configs = resnext3d_configs.model_configs['heads'][0]
in_plane = heads_configs['in_plane']
num_classes = heads_configs['num_classes']
act_func = heads_configs['activation_func']
mkldnn_head_fcl = MkldnnFullyConvolutionalLinear(in_plane, num_classes, act_func)
if args.evaluate:
model = model.eval()
model = mkldnn_utils.to_mkldnn(model)
model._heads['pathway0-stage4-block2']['default_head'].head_fcl = mkldnn_head_fcl.eval()
else:
model._heads['pathway0-stage4-block2']['default_head'].head_fcl = mkldnn_head_fc
# print(model)
if args.evaluate:
validata(datasets, model, loss, meters, args)
return
train(datasets, model, loss, optimizer, meters, args)
