def register_module_dataclass(cs: ConfigStore, registry: Dict[str, Any],
group: str) -> None:
"""register dataclasses defined in modules in config store, for example, in migrated tasks, models, etc."""
# note that if `group == model`, we register all model archs, not the model name.
for k, v in registry.items():
if v is not None:
node_ = v(_name=k)
cs.store(name=k, group=group, node=node_)
def register_hydra_cfg(cs: ConfigStore, name: str = "default") -> None:
"""cs: config store instance, register common training configs"""
for k, v in CONFIGS.items():
try:
cs.store(name=k, node=v())
except BaseException:
logger.error(f"{k} - {v()}")
raise
register_module_dataclass(cs, TASK_DATACLASS_REGISTRY, "task")
register_module_dataclass(cs, MODEL_DATACLASS_REGISTRY, "model")
for k, v in REGISTRIES.items():
register_module_dataclass(cs, v["dataclass_registry"], k)
def register_params_dataclass(
cs: ConfigStore, name: str, group: str, data_class: Type[FairseqDataclass]
) -> None:
"""register params dataclass in config store"""
node_ = data_class(_name=data_class.name())
cs.store(name=name, group=group, node=node_)
different_person = self.loss(sub1_target, sub2_truth)
logits = softmax(torch.tensor([same_person, different_person]))
acc = self.accuracy(logits, torch.tensor([1, 0]))
self.log('same person', same_person)
self.log('different person', different_person)
self.log('accuracy', acc)
def configure_optimizers(self):
return Adam(self.parameters(), lr=1e-3)
@hydra.main(config_name='eeg')
def main(cfg: EEGLearnerConfig):
cfg.correlation = True
cfg.data.load = True
data = EEGDataModule(cfg, use_criteria=True)
model = DomainAdaptation(nn.Embedding(164, 10), nn.Embedding(164, 5))
trainer = pl.Trainer()
trainer.fit(model, datamodule=data)
trainer.test(model, datamodule=data)
if __name__ == '__main__':
cs = ConfigStore()
cs.store(name='eeg', node=EEGLearnerConfig)
main()
"""Module for training path + cycle model on OGB datasets."""
import torch
import torch.optim
import torch
import hydra
from hydra.core.config_store import ConfigStore
from torch_geometric.transforms import Compose
from autobahn.transform import Pathifier, Cyclifier, OGBTransform
from autobahn.experiments.data import OGBDataModule
from autobahn.experiments import combo_models, utils
cs = ConfigStore()
cs.store(name='config_ogb', node=combo_models.OGBTrainingConfiguration)
@hydra.main(config_name='config_ogb', config_path='conf')
def train_with_conf(config: combo_models.OGBTrainingConfiguration):
utils.ensure_config_defaults(config)
torch.manual_seed(config.seed)
transform = Compose([
OGBTransform(),
Pathifier(list(config.model.path_lengths)),
Cyclifier(list(config.model.cycle_lengths))
])
batch_split = max(config.num_gpus, 1)
dataset = OGBDataModule(config.data,
transform=transform,
import pytorch_lightning as pl
from data.dataset import TradeDataModule
from model.model import TradeModule
import neptune
from pytorch_lightning.loggers.neptune import NeptuneLogger
import hydra
from hydra.core.config_store import ConfigStore
from config.trade_config import TradeConfig
@hydra.main(config_name='trade')
def main(cfg: TradeConfig):
data = TradeDataModule(**dict(cfg.data))
model = TradeModule(cfg.data.look_back, data.ds.data.shape[1],
data.ds.full_data.shape[1])
trainer = pl.Trainer(logger=[NeptuneLogger(project_name='yoniosin/Trade')],
max_epochs=cfg.max_epochs,
fast_dev_run=True)
trainer.fit(model, datamodule=data)
if __name__ == '__main__':
# neptune.set_project('yoniosin/Trade')
cs = ConfigStore()
cs.store(name='trade', node=TradeConfig)
main()
@hydra.main(config_name='config_zinc', config_path='conf')
def train_with_conf(config: combo_models.ZincTrainingConfiguration):
trainer = utils.make_trainer(config)
torch.manual_seed(config.seed)
path_lengths, cycle_lengths = _expand_to_default(
config.model.path_lengths, config.model.cycle_lengths)
transform = Compose([Pathifier(path_lengths), Cyclifier(cycle_lengths)])
batch_split = max(config.num_gpus, 1)
dataset = ZincDataModule(config.data,
transform=transform,
batch_size=config.batch_size // batch_split)
dataset.prepare_data()
dataset.setup()
config.model.atom_feature_cardinality = dataset.atom_feature_cardinality
fixture = combo_models.ZincPathAndCycleModel(config)
trainer.fit(fixture, dataset)
if __name__ == '__main__':
from hydra.core.config_store import ConfigStore
cs = ConfigStore()
cs.store(name='base_config_zinc',
node=combo_models.ZincTrainingConfiguration)
train_with_conf()
