def main(configuration, init_distributed=False, predict=False):
# A reload might be needed for imports
setup_imports()
configuration.import_user_dir()
config = configuration.get_config()
if torch.cuda.is_available():
torch.cuda.set_device(config.device_id)
torch.cuda.init()
if init_distributed:
distributed_init(config)
config.training.seed = set_seed(config.training.seed)
registry.register("seed", config.training.seed)
print(f"Using seed {config.training.seed}")
config = build_config(configuration)
# Logger should be registered after config is registered
registry.register("writer", Logger(config, name="mmf.train"))
trainer = build_trainer(config)
trainer.load()
if predict:
trainer.inference()
else:
trainer.train()
def setUp(self):
test_utils.setup_proxy()
setup_imports()
model_name = "vilbert"
args = test_utils.dummy_args(model=model_name)
configuration = Configuration(args)
config = configuration.get_config()
model_class = registry.get_model_class(model_name)
self.vision_feature_size = 1024
self.vision_target_size = 1279
config.model_config[model_name]["training_head_type"] = "pretraining"
config.model_config[model_name][
"visual_embedding_dim"] = self.vision_feature_size
config.model_config[model_name][
"v_feature_size"] = self.vision_feature_size
config.model_config[model_name][
"v_target_size"] = self.vision_target_size
config.model_config[model_name]["dynamic_attention"] = False
self.pretrain_model = model_class(config.model_config[model_name])
self.pretrain_model.build()
config.model_config[model_name][
"training_head_type"] = "classification"
config.model_config[model_name]["num_labels"] = 2
self.finetune_model = model_class(config.model_config[model_name])
self.finetune_model.build()
def get_model(device, opts):
from mmf.utils.build import build_config, build_trainer
from mmf.common.registry import registry
from mmf.utils.configuration import Configuration
from mmf.utils.env import set_seed, setup_imports
args = argparse.Namespace(config_override=None)
args.opts = opts
configuration = Configuration(args)
configuration.args = args
config = configuration.get_config()
config.start_rank = 0
config.device_id = 0
setup_imports()
configuration.import_user_dir()
config = configuration.get_config()
if torch.cuda.is_available():
torch.cuda.set_device(config.device_id)
torch.cuda.init()
config.training.seed = set_seed(config.training.seed)
registry.register("seed", config.training.seed)
config = build_config(configuration)
# Logger should be registered after config is registered
registry.register("writer", Logger(config, name="mmf.train"))
trainer = build_trainer(config)
# trainer.load()
ready_trainer(trainer)
trainer.model.to(device)
return trainer.model
def main(configuration, init_distributed=False, predict=False):
# A reload might be needed for imports
setup_imports()
configuration.import_user_dir()
config = configuration.get_config()
if torch.cuda.is_available():
torch.cuda.set_device(config.device_id)
torch.cuda.init()
if init_distributed:
distributed_init(config)
seed = config.training.seed
config.training.seed = set_seed(seed if seed == -1 else seed + get_rank())
registry.register("seed", config.training.seed)
config = build_config(configuration)
setup_logger(color=config.training.colored_logs,
disable=config.training.should_not_log)
logger = logging.getLogger("mmf_cli.run")
# Log args for debugging purposes
logger.info(configuration.args)
logger.info(f"Torch version: {torch.__version__}")
log_device_names()
logger.info(f"Using seed {config.training.seed}")
trainer = build_trainer(config)
trainer.load()
if predict:
trainer.inference()
else:
trainer.train()
def setUp(self):
test_utils.setup_proxy()
setup_imports()
model_name = "vinvl"
args = test_utils.dummy_args(model=model_name, dataset="test")
configuration = Configuration(args)
config = configuration.get_config()
model_config = config.model_config[model_name]
model_config.model = model_name
model_config.do_pretraining = False
classification_config_dict = {
"do_pretraining": False,
"heads": {"mlp": {"num_labels": 3129}},
"ce_loss": {"ignore_index": -1},
}
self.classification_config = OmegaConf.create(
{**model_config, **classification_config_dict}
)
pretraining_config_dict = {
"do_pretraining": True,
"heads": {"mlm": {"hidden_size": 768}},
}
self.pretraining_config = OmegaConf.create(
{**model_config, **pretraining_config_dict}
)
self.sample_list = self._get_sample_list()
def setUp(self):
test_utils.setup_proxy()
setup_imports()
self.model_name = "mmf_transformer"
args = test_utils.dummy_args(model=self.model_name)
configuration = Configuration(args)
self.config = configuration.get_config()
self.config.model_config[self.model_name].model = self.model_name
def setUp(self):
test_utils.setup_proxy()
setup_imports()
model_name = "vilt"
args = test_utils.dummy_args(model=model_name, dataset="test")
configuration = Configuration(args)
config = configuration.get_config()
model_config = config.model_config[model_name]
model_config.model = model_name
self.pretrain_model = build_model(model_config)
def setUp(self):
setup_imports()
self.model_name = "mmf_transformer"
args = test_utils.dummy_args(model=self.model_name)
configuration = Configuration(args)
self.config = configuration.get_config()
self.model_class = registry.get_model_class(self.model_name)
self.finetune_model = self.model_class(
self.config.model_config[self.model_name])
self.finetune_model.build()
def run(opts: typing.Optional[typing.List[str]] = None, predict: bool = False):
"""Run starts a job based on the command passed from the command line.
You can optionally run the mmf job programmatically by passing an optlist as opts.
Args:
opts (typing.Optional[typing.List[str]], optional): Optlist which can be used.
to override opts programmatically. For e.g. if you pass
opts = ["training.batch_size=64", "checkpoint.resume=True"], this will
set the batch size to 64 and resume from the checkpoint if present.
Defaults to None.
predict (bool, optional): If predict is passed True, then the program runs in
prediction mode. Defaults to False.
"""
setup_imports()
if opts is None:
parser = flags.get_parser()
args = parser.parse_args()
else:
args = argparse.Namespace(config_override=None)
args.opts = opts
print(args)
configuration = Configuration(args)
# Do set runtime args which can be changed by MMF
configuration.args = args
config = configuration.get_config()
config.start_rank = 0
if config.distributed.init_method is None:
infer_init_method(config)
if config.distributed.init_method is not None:
if torch.cuda.device_count() > 1 and not config.distributed.no_spawn:
config.start_rank = config.distributed.rank
config.distributed.rank = None
torch.multiprocessing.spawn(
fn=distributed_main,
args=(configuration, predict),
nprocs=torch.cuda.device_count(),
)
else:
distributed_main(0, configuration, predict)
elif config.distributed.world_size > 1:
assert config.distributed.world_size <= torch.cuda.device_count()
port = random.randint(10000, 20000)
config.distributed.init_method = f"tcp://localhost:{port}"
config.distributed.rank = None
torch.multiprocessing.spawn(
fn=distributed_main,
args=(configuration, predict),
nprocs=config.distributed.world_size,
)
else:
config.device_id = 0
main(configuration, predict=predict)
def setUp(self):
test_utils.setup_proxy()
setup_imports()
replace_with_jit()
model_name = "visual_bert"
args = test_utils.dummy_args(model=model_name)
configuration = Configuration(args)
config = configuration.get_config()
model_config = config.model_config[model_name]
model_config.model = model_name
self.pretrain_model = build_model(model_config)
def setUp(self):
setup_imports()
model_name = "mmbt"
args = test_utils.dummy_args(model=model_name)
configuration = Configuration(args)
config = configuration.get_config()
model_class = registry.get_model_class(model_name)
config.model_config[model_name]["training_head_type"] = "classification"
config.model_config[model_name]["num_labels"] = 2
self.finetune_model = model_class(config.model_config[model_name])
self.finetune_model.build()
def setUp(self):
test_utils.setup_proxy()
setup_imports()
model_name = "mmbt"
args = test_utils.dummy_args(model=model_name)
configuration = Configuration(args)
config = configuration.get_config()
model_config = config.model_config[model_name]
model_config["training_head_type"] = "classification"
model_config["num_labels"] = 2
model_config.model = model_name
self.finetune_model = build_model(model_config)
def setUp(self):
test_utils.setup_proxy()
setup_imports()
model_name = "uniter"
args = test_utils.dummy_args(model=model_name, dataset="vqa2")
configuration = Configuration(args)
config = configuration.get_config()
model_config = config.model_config[model_name]
model_config.model = model_name
model_config.losses = {"vqa2": "logit_bce"}
model_config.do_pretraining = False
model_config.tasks = "vqa2"
classification_config_dict = {
"do_pretraining": False,
"tasks": "vqa2",
"heads": {
"vqa2": {
"type": "mlp",
"num_labels": 3129
}
},
"losses": {
"vqa2": "logit_bce"
},
}
classification_config = OmegaConf.create({
**model_config,
**classification_config_dict
})
pretraining_config_dict = {
"do_pretraining": True,
"tasks": "wra",
"heads": {
"wra": {
"type": "wra"
}
},
}
pretraining_config = OmegaConf.create({
**model_config,
**pretraining_config_dict
})
self.model_for_classification = build_model(classification_config)
self.model_for_pretraining = build_model(pretraining_config)
def initialize(self, ctx):
self.manifest = ctx.manifest
properties = ctx.system_properties
model_dir = properties.get("model_dir")
serialized_file = self.manifest['model']['serializedFile']
model_pt_path = os.path.join(model_dir, serialized_file)
self.map_location = "cuda" if torch.cuda.is_available() else "cpu"
self.device = torch.device(self.map_location + ":" +
str(properties.get("gpu_id")) if torch.cuda.
is_available() else self.map_location)
# reading the csv file which include all the labels in the dataset to make the class/index mapping
# and matching the output of the model with num labels from dataset
df = pd.read_csv('./charades_action_lables.csv')
label_set = set()
df['action_labels'] = df['action_labels'].str.replace('"', '')
labels_initial = df['action_labels'].tolist()
labels = []
for sublist in labels_initial:
new_sublist = ast.literal_eval(sublist)
labels.append(new_sublist)
for item in new_sublist:
label_set.add(item)
classes = sorted(list(label_set))
self.class_to_idx = {classes[i]: i for i in range(len(classes))}
self.classes = classes
self.labels = labels
self.idx_to_class = classes
config = OmegaConf.load('config.yaml')
print("*********** config keyssss **********", config.keys())
setup_very_basic_config()
setup_imports()
self.model = MMFTransformer(config.model_config.mmf_transformer)
self.model.build()
self.model.init_losses()
self.processor = build_processors(
config.dataset_config["charades"].processors)
state_dict = torch.load(serialized_file, map_location=self.device)
self.model.load_state_dict(state_dict)
self.model.to(self.device)
self.model.eval()
self.initialized = True
print(
"********* files in temp direcotry that .mar file got extracted *********",
os.listdir(model_dir))
def setUp(self):
test_utils.setup_proxy()
setup_imports()
model_name = "vilbert"
args = test_utils.dummy_args(model=model_name)
configuration = Configuration(args)
config = configuration.get_config()
self.vision_feature_size = 1024
self.vision_target_size = 1279
model_config = config.model_config[model_name]
model_config["training_head_type"] = "pretraining"
model_config["visual_embedding_dim"] = self.vision_feature_size
model_config["v_feature_size"] = self.vision_feature_size
model_config["v_target_size"] = self.vision_target_size
model_config["dynamic_attention"] = False
model_config.model = model_name
model_config["training_head_type"] = "classification"
model_config["num_labels"] = 2
self.model_config = model_config
def setUp(self):
test_utils.setup_proxy()
setup_imports()
self._image_modality_config = MMFTransformerModalityConfig(
type="image",
key="image",
embedding_dim=256,
position_dim=1,
segment_id=0,
encoder=ImageEncoderFactory.Config(
type=ImageEncoderTypes.identity),
)
self._text_modality_config = MMFTransformerModalityConfig(
type="text",
key="text",
embedding_dim=756,
position_dim=128,
segment_id=1,
encoder=TextEncoderFactory.Config(type=TextEncoderTypes.identity),
)
def setUp(self):
setup_imports()
torch.manual_seed(1234)
config_path = os.path.join(
get_mmf_root(),
"..",
"projects",
"butd",
"configs",
"coco",
"beam_search.yaml",
)
config_path = os.path.abspath(config_path)
args = dummy_args(model="butd", dataset="coco")
args.opts.append(f"config={config_path}")
configuration = Configuration(args)
configuration.config.datasets = "coco"
configuration.freeze()
self.config = configuration.config
registry.register("config", self.config)
def setUp(self):
setup_imports()
torch.manual_seed(1234)
config_path = os.path.join(
get_mmf_root(),
"..",
"projects",
"butd",
"configs",
"coco",
"nucleus_sampling.yaml",
)
config_path = os.path.abspath(config_path)
args = dummy_args(model="butd", dataset="coco")
args.opts.append(f"config={config_path}")
configuration = Configuration(args)
configuration.config.datasets = "coco"
configuration.config.model_config.butd.inference.params.sum_threshold = 0.5
configuration.freeze()
self.config = configuration.config
registry.register("config", self.config)
def run(predict=False):
setup_imports()
parser = flags.get_parser()
args = parser.parse_args()
print(args)
configuration = Configuration(args)
# Do set runtime args which can be changed by MMF
configuration.args = args
config = configuration.get_config()
config.start_rank = 0
if config.distributed.init_method is None:
infer_init_method(config)
if config.distributed.init_method is not None:
if torch.cuda.device_count() > 1 and not config.distributed.no_spawn:
config.start_rank = config.distributed.rank
config.distributed.rank = None
torch.multiprocessing.spawn(
fn=distributed_main,
args=(configuration, predict),
nprocs=torch.cuda.device_count(),
)
else:
distributed_main(0, configuration, predict)
elif config.distributed.world_size > 1:
assert config.distributed.world_size <= torch.cuda.device_count()
port = random.randint(10000, 20000)
config.distributed.init_method = f"tcp://localhost:{port}"
config.distributed.rank = None
torch.multiprocessing.spawn(
fn=distributed_main,
args=(configuration, predict),
nprocs=config.distributed.world_size,
)
else:
config.device_id = 0
main(configuration, predict=predict)
if ("writer" in cls.mapping["state"] and value == default
and no_warning is False):
cls.mapping["state"]["writer"].warning(
"Key {} is not present in registry, returning default value "
"of {}".format(original_name, default))
return value
@classmethod
def unregister(cls, name):
r"""Remove an item from registry with key 'name'
Args:
name: Key which needs to be removed.
Usage::
from mmf.common.registry import registry
config = registry.unregister("config")
"""
return cls.mapping["state"].pop(name, None)
registry = Registry()
# Only setup imports in main process, this means registry won't be
# fully available in spawned child processes (such as dataloader processes)
# but instantiated. This is to prevent issues such as
# https://github.com/facebookresearch/mmf/issues/355
if __name__ == "__main__":
setup_imports()
def setUp(self):
setup_imports()
self._initial_modules = set(sys.modules)
self._sanitize_registry()
def setUp(self):
setup_imports()
