def main():
args = arg_parse()
# ---- setup device ----
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print('==> Using device ' + device)
# ---- setup config ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
seed.set_seed(cfg.SOLVER.SEED)
# ---- setup logger ----
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
logger = logging.construct_logger('context_cnns', cfg.OUTPUT_DIR)
logger.info(f'Using {device}')
logger.info('\n' + cfg.dump())
# ---- setup dataset ----
train_loader, val_loader = get_cifar(cfg)
# ---- setup model ----
print('==> Building model..')
net = get_model(cfg)
net = net.to(device)
model_stats = summary(net, (3, 32, 32), depth=10)
logger.info('\n'+str(model_stats))
if device=='cuda':
net = torch.nn.DataParallel(net)
# ---- setup trainers ----
optim = torch.optim.SGD(net.parameters(), lr=cfg.SOLVER.BASE_LR,
momentum=cfg.SOLVER.MOMENTUM,
weight_decay=cfg.SOLVER.WEIGHT_DECAY)
trainer = Trainer(
device,
train_loader,
val_loader,
net,
optim,
logger,
cfg
)
if args.resume:
# Load checkpoint
print('==> Resuming from checkpoint..')
cp = torch.load(args.resume)
trainer.model.load_state_dict(cp['net'])
trainer.optim.load_state_dict(cp['optim'])
trainer.epochs = cp['epoch']
trainer.train_acc = cp['train_accuracy']
trainer.val_acc = cp['test_accuracy']
trainer.train()
def main():
"""The main for this domain adapation example, showing the workflow"""
args = arg_parse()
# ---- setup device ----
device = "cuda" if torch.cuda.is_available() else "cpu"
print("==> Using device " + device)
# ---- setup configs ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
set_seed(cfg.SOLVER.SEED)
# ---- setup logger and output ----
output_dir = os.path.join(cfg.OUTPUT_DIR, cfg.DATASET.NAME, args.output)
os.makedirs(output_dir, exist_ok=True)
logger = construct_logger("isonet", output_dir)
logger.info("Using " + device)
logger.info("\n" + cfg.dump())
# ---- setup dataset ----
train_loader, val_loader = get_cifar(cfg)
print("==> Building model..")
net = get_model(cfg)
# print(net)
net = net.to(device)
# model_stats = summary(net, (3, 32, 32))
# logger.info('\n'+str(model_stats))
# Needed even for single GPU https://discuss.pytorch.org/t/attributeerror-net-object-has-no-attribute-module/45652
if device == "cuda":
net = torch.nn.DataParallel(net)
optim = torch.optim.SGD(
net.parameters(),
lr=cfg.SOLVER.BASE_LR,
momentum=cfg.SOLVER.MOMENTUM,
weight_decay=cfg.SOLVER.WEIGHT_DECAY,
dampening=cfg.SOLVER.DAMPENING,
nesterov=cfg.SOLVER.NESTEROV,
)
trainer = Trainer(device, train_loader, val_loader, net, optim, logger,
output_dir, cfg)
if args.resume:
# Load checkpoint
print("==> Resuming from checkpoint..")
cp = torch.load(args.resume)
trainer.model.load_state_dict(cp["net"])
trainer.optim.load_state_dict(cp["optim"])
trainer.epochs = cp["epoch"]
trainer.train_acc = cp["train_accuracy"]
trainer.val_acc = cp["test_accuracy"]
trainer.train()
def main():
"""The main for this multi-source domain adaptation example, showing the workflow"""
args = arg_parse()
# ---- setup configs ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
print(cfg)
# ---- setup output ----
format_str = "@%(asctime)s %(name)s [%(levelname)s] - (%(message)s)"
logging.basicConfig(format=format_str)
# ---- setup dataset ----
if type(cfg.DATASET.SOURCE) == list:
sub_domain_set = cfg.DATASET.SOURCE + [cfg.DATASET.TARGET]
else:
sub_domain_set = None
num_channels = cfg.DATASET.NUM_CHANNELS
if cfg.DATASET.NAME.upper() == "DIGITS":
kwargs = {"return_domain_label": True}
else:
kwargs = {"download": True, "return_domain_label": True}
data_access = ImageAccess.get_multi_domain_images(
cfg.DATASET.NAME.upper(), cfg.DATASET.ROOT, sub_domain_set=sub_domain_set, **kwargs
)
# Repeat multiple times to get std
for i in range(0, cfg.DATASET.NUM_REPEAT):
seed = cfg.SOLVER.SEED + i * 10
dataset = MultiDomainAdapDataset(data_access, random_state=seed)
set_seed(seed) # seed_everything in pytorch_lightning did not set torch.backends.cudnn
print(f"==> Building model for seed {seed} ......")
# ---- setup model and logger ----
model, train_params = get_model(cfg, dataset, num_channels)
tb_logger = TensorBoardLogger(cfg.OUTPUT.TB_DIR, name="seed{}".format(seed))
checkpoint_callback = ModelCheckpoint(
filename="{epoch}-{step}-{valid_loss:.4f}", monitor="valid_loss", mode="min",
)
progress_bar = TQDMProgressBar(cfg.OUTPUT.PB_FRESH)
trainer = pl.Trainer(
min_epochs=cfg.SOLVER.MIN_EPOCHS,
max_epochs=cfg.SOLVER.MAX_EPOCHS,
callbacks=[checkpoint_callback, progress_bar],
gpus=args.gpus,
auto_select_gpus=True,
logger=tb_logger, # logger,
# weights_summary='full',
fast_dev_run=False, # True,
)
trainer.fit(model)
trainer.test()
def main():
"""The main for this domain adaptation example, showing the workflow"""
args = arg_parse()
# ---- setup configs ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
print(cfg)
# ---- setup output ----
os.makedirs(cfg.OUTPUT.DIR, exist_ok=True)
format_str = "@%(asctime)s %(name)s [%(levelname)s] - (%(message)s)"
logging.basicConfig(format=format_str)
# ---- setup dataset ----
source, target, num_channels = VideoDataset.get_source_target(
VideoDataset(cfg.DATASET.SOURCE.upper()), VideoDataset(cfg.DATASET.TARGET.upper()), cfg
)
dataset = MultiDomainDatasets(
source, target, config_weight_type=cfg.DATASET.WEIGHT_TYPE, config_size_type=cfg.DATASET.SIZE_TYPE
)
# Repeat multiple times to get std
for i in range(0, cfg.DATASET.NUM_REPEAT):
seed = cfg.SOLVER.SEED + i * 10
set_seed(seed) # seed_everything in pytorch_lightning did not set torch.backends.cudnn
print(f"==> Building model for seed {seed} ......")
# ---- setup model and logger ----
model, train_params = get_model(cfg, dataset, num_channels)
logger, results, checkpoint_callback, test_csv_file = setup_logger(
train_params, cfg.OUTPUT.DIR, cfg.DAN.METHOD, seed
)
tb_logger = pl_loggers.TensorBoardLogger(cfg.OUTPUT.TB_DIR)
trainer = pl.Trainer(
progress_bar_refresh_rate=cfg.OUTPUT.PB_FRESH, # in steps
min_epochs=cfg.SOLVER.MIN_EPOCHS,
max_epochs=cfg.SOLVER.MAX_EPOCHS,
checkpoint_callback=checkpoint_callback,
# resume_from_checkpoint=last_checkpoint_file,
gpus=args.gpus,
logger=tb_logger, # logger,
# weights_summary='full',
fast_dev_run=cfg.OUTPUT.FAST_DEV_RUN, # True,
)
trainer.fit(model)
results.update(
is_validation=True, method_name=cfg.DAN.METHOD, seed=seed, metric_values=trainer.callback_metrics,
)
# test scores
trainer.test()
results.update(
is_validation=False, method_name=cfg.DAN.METHOD, seed=seed, metric_values=trainer.callback_metrics,
)
results.to_csv(test_csv_file)
results.print_scores(cfg.DAN.METHOD)
def main():
"""The main for this domain adaptation example, showing the workflow"""
args = arg_parse()
# ---- setup configs ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
print(cfg)
# ---- setup output ----
format_str = "@%(asctime)s %(name)s [%(levelname)s] - (%(message)s)"
logging.basicConfig(format=format_str)
# ---- setup dataset ----
source, target, num_channels = DigitDataset.get_source_target(
DigitDataset(cfg.DATASET.SOURCE.upper()),
DigitDataset(cfg.DATASET.TARGET.upper()), cfg.DATASET.ROOT)
dataset = MultiDomainDatasets(
source,
target,
config_weight_type=cfg.DATASET.WEIGHT_TYPE,
config_size_type=cfg.DATASET.SIZE_TYPE,
valid_split_ratio=cfg.DATASET.VALID_SPLIT_RATIO,
)
# Repeat multiple times to get std
for i in range(0, cfg.DATASET.NUM_REPEAT):
seed = cfg.SOLVER.SEED + i * 10
# seed_everything in pytorch_lightning did not set torch.backends.cudnn
set_seed(seed)
print(f"==> Building model for seed {seed} ......")
# ---- setup model and logger ----
model, train_params = get_model(cfg, dataset, num_channels)
tb_logger = pl_loggers.TensorBoardLogger(cfg.OUTPUT.TB_DIR,
name="seed{}".format(seed))
checkpoint_callback = ModelCheckpoint(
filename="{epoch}-{step}-{valid_loss:.4f}",
monitor="valid_loss",
mode="min",
)
progress_bar = TQDMProgressBar(cfg.OUTPUT.PB_FRESH)
trainer = pl.Trainer(
min_epochs=cfg.SOLVER.MIN_EPOCHS,
max_epochs=cfg.SOLVER.MAX_EPOCHS,
callbacks=[checkpoint_callback, progress_bar],
logger=tb_logger,
gpus=args.gpus,
)
trainer.fit(model)
trainer.test()
def main():
args = arg_parse()
# ---- setup device ----
device = "cuda" if torch.cuda.is_available() else "cpu"
print("==> Using device " + device)
# ---- setup config ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
seed.set_seed(cfg.SOLVER.SEED)
# ---- setup logger ----
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)
logger = logging.construct_logger("context_cnns", cfg.OUTPUT_DIR)
logger.info(f"Using {device}")
logger.info("\n" + cfg.dump())
# ---- setup dataset ----
train_loader, valid_loader = get_cifar(cfg)
# ---- setup model ----
print("==> Building model..")
net = get_model(cfg)
net = net.to(device)
model_stats = summary(net, (3, 32, 32))
logger.info("\n" + str(model_stats))
if device == "cuda":
net = torch.nn.DataParallel(net)
# ---- setup trainers ----
optim = torch.optim.SGD(
net.parameters(), lr=cfg.SOLVER.BASE_LR, momentum=cfg.SOLVER.MOMENTUM, weight_decay=cfg.SOLVER.WEIGHT_DECAY
)
trainer = Trainer(device, train_loader, valid_loader, net, optim, logger, cfg)
if args.resume:
# Load checkpoint
print("==> Resuming from checkpoint..")
cp = torch.load(args.resume)
trainer.model.load_state_dict(cp["net"])
trainer.optim.load_state_dict(cp["optim"])
trainer.epochs = cp["epoch"]
trainer.train_acc = cp["train_accuracy"]
trainer.valid_acc = cp["test_accuracy"]
trainer.train()
def main():
args = arg_parse()
# ---- setup device ----
device = "cuda" if torch.cuda.is_available() else "cpu"
print("==> Using device " + device)
# ---- setup configs ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
seed.set_seed(cfg.SOLVER.SEED)
# ---- setup logger and output ----
output_dir = os.path.join(cfg.OUTPUT_DIR, cfg.DATASET.NAME, args.output)
os.makedirs(output_dir, exist_ok=True)
logger = lu.construct_logger("gripnet", output_dir)
logger.info("Using " + device)
logger.info(cfg.dump())
# ---- setup dataset ----
download_file_by_url(cfg.DATASET.URL, cfg.DATASET.ROOT, "pose.pt", "pt")
data = torch.load(os.path.join(cfg.DATASET.ROOT, "pose.pt"))
device = torch.device(device)
data = data.to(device)
# ---- setup model ----
print("==> Building model..")
model = GripNet(
cfg.GRIPN.GG_LAYERS, cfg.GRIPN.GD_LAYERS, cfg.GRIPN.DD_LAYERS, data.n_d_node, data.n_g_node, data.n_dd_edge_type
).to(device)
# TODO Visualize model
# ---- setup trainers ----
optimizer = torch.optim.Adam(model.parameters(), lr=cfg.SOLVER.BASE_LR)
# TODO
trainer = Trainer(cfg, device, data, model, optimizer, logger, output_dir)
if args.resume:
# Load checkpoint
print("==> Resuming from checkpoint..")
cp = torch.load(args.resume)
trainer.model.load_state_dict(cp["net"])
trainer.optim.load_state_dict(cp["optim"])
trainer.epochs = cp["epoch"]
trainer.train_auprc = cp["train_auprc"]
trainer.valid_auprc = cp["valid_auprc"]
trainer.train_auroc = cp["train_auroc"]
trainer.valid_auroc = cp["valid_auroc"]
trainer.train_ap = cp["train_ap"]
trainer.valid_ap = cp["valid_ap"]
trainer.train()
def main():
args = arg_parse()
# ---- setup device ----
device = 'cuda' if torch.cuda.is_available() else 'cpu'
print('==> Using device ' + device)
# ---- setup configs ----
C.merge_from_file(args.cfg)
C.freeze()
seed.set_seed(C.SOLVER.SEED)
# ---- setup logger and output ----
output_dir = os.path.join(C.OUTPUT_DIR, C.DATASET.NAME, args.output)
os.makedirs(output_dir, exist_ok=True)
logger = lu.construct_logger('gripnet', output_dir)
logger.info('Using ' + device)
logger.info(C.dump())
# ---- setup dataset ----
data = construct_dataset(C)
device = torch.device(device)
data = data.to(device)
# ---- setup model ----
print('==> Building model..')
model = GripNet(C.GRIPN.GG_LAYERS, C.GRIPN.GD_LAYERS, C.GRIPN.DD_LAYERS,
data.n_d_node, data.n_g_node,
data.n_dd_edge_type).to(device)
# TODO Visualize model
# ---- setup trainers ----
optimizer = torch.optim.Adam(model.parameters(), lr=C.SOLVER.BASE_LR)
# TODO
trainer = Trainer(C, device, data, model, optimizer, logger, output_dir)
if args.resume:
# Load checkpoint
print('==> Resuming from checkpoint..')
cp = torch.load(args.resume)
trainer.model.load_state_dict(cp['net'])
trainer.optim.load_state_dict(cp['optim'])
trainer.epochs = cp['epoch']
trainer.train_auprc = cp['train_auprc']
trainer.val_auprc = cp['val_auprc']
trainer.train_auroc = cp['train_auroc']
trainer.val_auroc = cp['val_auroc']
trainer.train_ap = cp['train_ap']
trainer.val_ap = cp['val_ap']
trainer.train()
def test_shapes():
set_seed(36)
CNN_OUT_HEIGHT = 32
CNN_OUT_WIDTH = 32
CNN_OUT_CHANNELS = 256
cnn = nn.Sequential(
nn.Conv2d(in_channels=3,
out_channels=CNN_OUT_CHANNELS,
kernel_size=3,
padding=1), nn.MaxPool2d(kernel_size=2))
cnn_transformer = CNNTransformer(
cnn=cnn,
cnn_output_shape=(-1, CNN_OUT_CHANNELS, CNN_OUT_HEIGHT, CNN_OUT_WIDTH),
num_layers=4,
num_heads=4,
dim_feedforward=1024,
dropout=0.1,
output_type="spatial",
positional_encoder=None,
)
cnn_transformer.eval()
BATCH_SIZE = 2
input_batch = torch.randn((BATCH_SIZE, 3, 64, 64))
out_spatial = cnn_transformer(input_batch)
cnn_transformer.output_type = "sequence"
out_seq = cnn_transformer(input_batch)
assert out_spatial.size() == (BATCH_SIZE, CNN_OUT_CHANNELS, CNN_OUT_HEIGHT,
CNN_OUT_WIDTH)
assert out_seq.size() == (CNN_OUT_HEIGHT * CNN_OUT_WIDTH, BATCH_SIZE,
CNN_OUT_CHANNELS)
# simply reshape them both to have same shape
out_spatial_2 = seq_to_spatial(out_seq, CNN_OUT_HEIGHT, CNN_OUT_WIDTH)
testing.assert_almost_equal(out_spatial.detach().numpy(),
out_spatial_2.detach().numpy())
def test_set_seed_torch(torch_rand):
set_seed()
result = torch.rand(1).item()
testing.assert_equal(result, torch_rand)
def test_set_seed_numpy(np_rand):
set_seed()
result = np.random.rand()
testing.assert_equal(result, np_rand)
def test_set_seed_base(base_rand):
set_seed()
result = random.random()
testing.assert_equal(result, base_rand)
def main():
"""The main for this domain adaptation example, showing the workflow"""
args = arg_parse()
# ---- setup configs ----
cfg = get_cfg_defaults()
cfg.merge_from_file(args.cfg)
cfg.freeze()
print(cfg)
# ---- setup output ----
format_str = "@%(asctime)s %(name)s [%(levelname)s] - (%(message)s)"
logging.basicConfig(format=format_str)
# ---- setup dataset ----
seed = cfg.SOLVER.SEED
source, target, num_classes = VideoDataset.get_source_target(
VideoDataset(cfg.DATASET.SOURCE.upper()), VideoDataset(cfg.DATASET.TARGET.upper()), seed, cfg
)
dataset = VideoMultiDomainDatasets(
source,
target,
image_modality=cfg.DATASET.IMAGE_MODALITY,
seed=seed,
config_weight_type=cfg.DATASET.WEIGHT_TYPE,
config_size_type=cfg.DATASET.SIZE_TYPE,
)
# ---- training/test process ----
### Repeat multiple times to get std
for i in range(0, cfg.DATASET.NUM_REPEAT):
seed = seed + i * 10
set_seed(seed) # seed_everything in pytorch_lightning did not set torch.backends.cudnn
print(f"==> Building model for seed {seed} ......")
# ---- setup model and logger ----
model, train_params = get_model(cfg, dataset, num_classes)
tb_logger = pl_loggers.TensorBoardLogger(cfg.OUTPUT.TB_DIR, name="seed{}".format(seed))
checkpoint_callback = ModelCheckpoint(
# dirpath=full_checkpoint_dir,
filename="{epoch}-{step}-{valid_loss:.4f}",
# save_last=True,
# save_top_k=1,
monitor="valid_loss",
mode="min",
)
### Set early stopping
# early_stop_callback = EarlyStopping(monitor="valid_target_acc", min_delta=0.0000, patience=100, mode="max")
lr_monitor = LearningRateMonitor(logging_interval="epoch")
progress_bar = TQDMProgressBar(cfg.OUTPUT.PB_FRESH)
### Set the lightning trainer. Comment `limit_train_batches`, `limit_val_batches`, `limit_test_batches` when
# training. Uncomment and change the ratio to test the code on the smallest sub-dataset for efficiency in
# debugging. Uncomment early_stop_callback to activate early stopping.
trainer = pl.Trainer(
min_epochs=cfg.SOLVER.MIN_EPOCHS,
max_epochs=cfg.SOLVER.MAX_EPOCHS,
# resume_from_checkpoint=last_checkpoint_file,
gpus=args.gpus,
logger=tb_logger, # logger,
# weights_summary='full',
fast_dev_run=cfg.OUTPUT.FAST_DEV_RUN, # True,
callbacks=[lr_monitor, checkpoint_callback, progress_bar],
# callbacks=[early_stop_callback, lr_monitor],
# limit_train_batches=0.005,
# limit_val_batches=0.06,
# limit_test_batches=0.06,
)
### Find learning_rate
# lr_finder = trainer.tuner.lr_find(model, max_lr=0.1, min_lr=1e-6)
# fig = lr_finder.plot(suggest=True)
# fig.show()
# logging.info(lr_finder.suggestion())
### Training/validation process
trainer.fit(model)
### Test process
trainer.test()
# import os
# import sys
# sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
# import kale
# from kale.embed import image_cnn, mpca, positional_encoding, attention_cnn
# from kale.loaddata import cifar_access, dataset_access, digits_access, mnistm, multi_domain, sampler, usps, videos
# # from kale.pipeline import domain_adapter # need pytorch-lightning
# from kale.predict import class_domain_nets, isonet, losses
# from kale.prepdata import image_transform, prep_cmr, tensor_reshape, video_transform
# from kale.utils import csv_logger, logger, seed
import logging
from kale.utils import seed
seed.set_seed(2020)
""" These only work with the optional graph modules
from kale.embed import gcn, gripnet
"""
logging.getLogger().setLevel(logging.INFO)
logging.info("kale imported")
"KITCHEN;6;kitchen_train.pkl;kitchen_test.pkl",
]
TARGETS = [
"EPIC;8;epic_D1_train.pkl;epic_D1_test.pkl",
# "ADL;7;adl_P_04_train.pkl;adl_P_04_test.pkl",
# "GTEA;6;gtea_train.pkl;gtea_test.pkl",
# "KITCHEN;6;kitchen_train.pkl;kitchen_test.pkl",
]
ALL = SOURCES + TARGETS
IMAGE_MODALITY = ["rgb", "flow", "joint"]
WEIGHT_TYPE = ["natural", "balanced", "preset0"]
# DATASIZE_TYPE = ["max", "source"]
DATASIZE_TYPE = ["max"]
VALID_RATIO = [0.1]
seed = 36
set_seed(seed)
CLASS_SUBSETS = [[1, 3, 8]]
root_dir = os.path.dirname(os.path.dirname(os.getcwd()))
url = "https://github.com/pykale/data/raw/main/videos/video_test_data.zip"
@pytest.fixture(scope="module")
def testing_cfg(download_path):
cfg = CN()
cfg.DATASET = CN()
cfg.DATASET.ROOT = root_dir + "/" + download_path + "/video_test_data/"
cfg.DATASET.IMAGE_MODALITY = "joint"
cfg.DATASET.FRAMES_PER_SEGMENT = 16
yield cfg
import pytest
import torch
from kale.predict.class_domain_nets import (
ClassNetSmallImage,
ClassNetVideo,
ClassNetVideoConv,
DomainNetSmallImage,
DomainNetVideo,
SoftmaxNet,
)
from kale.utils.seed import set_seed
set_seed(36)
BATCH_SIZE = 2
# The default input shape for basic ClassNet and DomainNet is batch_size * dimension. However, for ClassNetVideoConv,
# the input is the output of the I3D last average pooling layer and the shape is
# batch_size * num_channel * frame_per_segment * height * weight.
INPUT_BATCH = torch.randn(BATCH_SIZE, 128)
INPUT_BATCH_AVERAGE = torch.randn(BATCH_SIZE, 1024, 1, 1, 1)
CLASSNET_MODEL = [ClassNetSmallImage, ClassNetVideo]
DOMAINNET_MODEL = [DomainNetSmallImage, DomainNetVideo]
def test_softmaxnet_shapes():
model = SoftmaxNet(input_dim=128, n_classes=8)
model.eval()
output_batch = model(INPUT_BATCH)
assert output_batch.size() == (BATCH_SIZE, 8)
