print("can't import tqdm. progress bar is disabled")
tqdm = lambda x: x
import torch
import torchvision
from torchvision import transforms
from torch.utils.data import Dataset, DataLoader
##setup imagebackend
from torchvision import get_image_backend, set_image_backend
try:
import accimage
set_image_backend("accimage")
except:
print("accimage is not available")
print("image backend: %s" % get_image_backend())
# imports from my own script
import utils
utils.make_deterministic(123)
from dataloaders.ImagePandasDataset import ImagePandasDataset
from dataloaders.NShotTaskSampler import NShotTaskSampler
from dataloaders.WrapImagePandasDataset import WrapImagePandasDataset
from metrics.AverageMeter import AverageMeter
from metrics.accuracy import accuracy
from modules.layers.Flatten import Flatten
from modules.layers.Identity import Identity
from modules.metamodels.Baselines import Baselines
from modules.metamodels.ProtoNet import ProtoNet
from modules.metamodels.MetaModel import MetaModel
from modules.fusionnets.ImageFusionNet import ImageFusionNet
def default_image_loader(path):
if torchvision.get_image_backend() == "accimage":
return accimage_loader(path)
return pil_loader(path)
def default_loader(path):
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path)
def get_inference_data(video_path,
annotation_path,
dataset_name,
input_type,
file_type,
inference_subset,
spatial_transform=None,
temporal_transform=None,
target_transform=None):
assert dataset_name in [
'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'mit', 'faceforensics'
]
assert input_type in ['rgb', 'flow']
assert file_type in ['jpg', 'hdf5']
assert inference_subset in ['train', 'val', 'test']
if file_type == 'jpg':
assert input_type == 'rgb', 'flow input is supported only when input type is hdf5.'
if get_image_backend() == 'accimage':
from datasets.loader import ImageLoaderAccImage
loader = VideoLoader(image_name_formatter, ImageLoaderAccImage())
else:
loader = VideoLoader(image_name_formatter)
video_path_formatter = (
lambda root_path, label, video_id: root_path / label / video_id)
else:
if input_type == 'rgb':
loader = VideoLoaderHDF5()
else:
loader = VideoLoaderFlowHDF5()
video_path_formatter = (lambda root_path, label, video_id: root_path /
label / f'{video_id}.hdf5')
if inference_subset == 'train':
subset = 'training'
elif inference_subset == 'val':
subset = 'validation'
elif inference_subset == 'test':
subset = 'testing'
if dataset_name == 'activitynet':
inference_data = ActivityNet(video_path,
annotation_path,
subset,
spatial_transform=spatial_transform,
temporal_transform=temporal_transform,
target_transform=target_transform,
video_loader=loader,
video_path_formatter=video_path_formatter,
is_untrimmed_setting=True)
else:
inference_data = VideoDatasetMultiClips(
video_path,
annotation_path,
subset,
spatial_transform=spatial_transform,
temporal_transform=temporal_transform,
target_transform=target_transform,
video_loader=loader,
video_path_formatter=video_path_formatter,
target_type=['video_id', 'segment'])
return inference_data, collate_fn
def get_default_image_loader():
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader
else:
return pil_loader
parser.add_argument('--data', metavar='PATH', required=True,
help='path to dataset')
parser.add_argument('--nThreads', '-j', default=2, type=int, metavar='N',
help='number of data loading threads (default: 2)')
parser.add_argument('--batchSize', '-b', default=256, type=int, metavar='N',
help='mini-batch size (1 = pure stochastic) Default: 256')
parser.add_argument('--accimage', action='store_true',
help='use accimage')
if __name__ == "__main__":
args = parser.parse_args()
if args.accimage:
torchvision.set_image_backend('accimage')
print('Using {}'.format(torchvision.get_image_backend()))
# Data loading code
transform = transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
train = datasets.ImageFolder(traindir, transform)
val = datasets.ImageFolder(valdir, transform)
train_loader = torch.utils.data.DataLoader(
def default_loader(path):
from torchvision import get_image_backend
if get_image_backend() == "accimage":
return accimage_loader(path)
else:
return pil_loader(path)
def default_loader(self, path):
"""Get default image loader for torchvision."""
if get_image_backend() == 'accimage':
return self.accimage_loader(path)
else:
return self.pil_loader(path)
parser.add_argument('--data', metavar='PATH', required=True,
help='path to dataset')
parser.add_argument('--nThreads', '-j', default=2, type=int, metavar='N',
help='number of data loading threads (default: 2)')
parser.add_argument('--batchSize', '-b', default=256, type=int, metavar='N',
help='mini-batch size (1 = pure stochastic) Default: 256')
parser.add_argument('--accimage', action='store_true',
help='use accimage')
if __name__ == "__main__":
args = parser.parse_args()
if args.accimage:
torchvision.set_image_backend('accimage')
print(('Using {}'.format(torchvision.get_image_backend())))
# Data loading code
transform = transforms.Compose([
transforms.RandomSizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
train = datasets.ImageFolder(traindir, transform)
val = datasets.ImageFolder(valdir, transform)
train_loader = torch.utils.data.DataLoader(
def __init__(self, config_name):
"""
Args:
config_name: name of a configuration module to import
"""
print('Config name: {}'.format(config_name))
self.cfg = import_config_by_name(config_name)
print(self.cfg)
print('Start preparing dataset')
self.prepare_dataset()
print('Finished preparing dataset')
print("torch.__version__=", torch.__version__)
torchvision.set_image_backend('accimage')
print("torchvision.get_image_backend()=",
torchvision.get_image_backend())
self.epochs_to_train = 500
self.base_learning_rate = 0.02 #0.05 # 0.01
self.lr_scales = (
(0, 0.1), # perform soft warm-up to reduce chance of divergence
(2, 0.2),
(4, 0.3),
(6, 0.5),
(8, 0.7),
(10, 1.0), # main learning rate multiplier
# (0, 1.0), # main learning rate multiplier
(int(0.90 * self.epochs_to_train), 0.1),
(int(0.95 * self.epochs_to_train), 0.01),
)
self.train_batch_size = 32
self.val_batch_size = 32
num_workers_train = 12
num_workers_val = 12
input_traits = default_input_traits()
labelmap = NameListDataset.getLabelmap()
model = detection_models.SingleShotDetector(self.cfg.backbone_specs,
self.cfg.multibox_specs,
input_traits['resolution'],
labelmap)
if True:
model_dp = torch.nn.DataParallel(model)
cudnn.benchmark = True
else:
model_dp = model
if torch.cuda.is_available():
model_dp.cuda()
self.model = model
self.model_dp = model_dp
# # experimental: disable running statistics, normalize by a single batch
# for child in model.children():
# for ii in range(len(child)):
# if type(child[ii]) == torch.nn.BatchNorm2d:
# child[ii].track_running_stats = False
build_target = BuildTargetFunctor(model)
map_to_network_input = image_anno_transforms.MapImageAndAnnoToInputWindow(
input_traits['resolution'])
def load_list(name):
path = os.path.join(self.cfg.train_val_split_dir, name + '.pkl')
with open(path, 'rb') as input:
return pickle.load(input)
self.train_dataset = NameListDataset(
dataset_list=load_list('train_list'),
image_transform=train_image_transform(),
image_and_anno_transform=train_image_and_annotation_transform(),
map_to_network_input=map_to_network_input,
build_target=build_target)
self.balanced_val_dataset = NameListDataset(
dataset_list=load_list('val_list'),
image_transform=None,
image_and_anno_transform=None,
map_to_network_input=map_to_network_input,
build_target=build_target)
# Data loading and augmentation pipeline for training
self.train_loader = torch.utils.data.DataLoader(
self.train_dataset,
batch_size=self.train_batch_size,
shuffle=True,
num_workers=num_workers_train,
collate_fn=extended_collate,
pin_memory=True)
# Data loading and augmentation pipeline for validation
self.val_loader = torch.utils.data.DataLoader(
self.balanced_val_dataset,
batch_size=self.val_batch_size,
shuffle=False,
num_workers=num_workers_val,
collate_fn=extended_collate,
pin_memory=True)
self.optimizer = None
self.train_iter = 0
self.epoch = 0
self.print_freq = 10
self.writer = None
self.run_dir = os.path.join('runs', self.cfg.run_name)
os.makedirs(self.run_dir, exist_ok=True)
self.snapshot_path = os.path.join(self.run_dir,
self.cfg.run_name + '.pth.tar')
pass
def get_default_image_loader():
if get_image_backend() == 'accimage':
return accimage_loader
else:
return pil_loader
def __loader(path):
if get_image_backend() == 'accimage':
return FaceDataset.__acc_loader(path)
else:
return FaceDataset.__pil_loader(path)
def load_data(args):
assert args.dataset in [
'kinetics', 'activitynet', 'ucf101', 'hmdb51', 'mit'
]
assert args.input_type in ['rgb', 'flow']
assert args.file_type in ['jpg', 'hdf5']
if args.file_type == 'jpg':
assert args.input_type == 'rgb', 'flow input is supported only when input type is hdf5.'
if get_image_backend() == 'accimage':
from dataset.loader import ImageLoaderAccImage
loader = VideoLoader(image_name_formatter, ImageLoaderAccImage())
else:
loader = VideoLoader(image_name_formatter)
video_path_formatter = (
lambda root_path, label, video_id: root_path / label / video_id)
else:
if args.input_type == 'rgb':
loader = VideoLoaderHDF5()
else:
loader = VideoLoaderFlowHDF5()
video_path_formatter = (lambda root_path, label, video_id: root_path /
label / f'{video_id}.hdf5')
spatial_transform, temporal_transform = ucf101(args, mode='train')
train_dataset = VideoDataset(args.video_path,
args.annotation_path,
'training',
spatial_transform=spatial_transform,
temporal_transform=temporal_transform,
target_transform=None,
video_loader=loader,
video_path_formatter=video_path_formatter)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=2,
pin_memory=True,
sampler=None,
worker_init_fn=worker_init_fn)
if args.file_type == 'jpg':
assert args.input_type == 'rgb', 'flow input is supported only when input type is hdf5.'
if get_image_backend() == 'accimage':
from dataset.loader import ImageLoaderAccImage
loader = VideoLoader(image_name_formatter, ImageLoaderAccImage())
else:
loader = VideoLoader(image_name_formatter)
video_path_formatter = (
lambda root_path, label, video_id: root_path / label / video_id)
else:
if args.input_type == 'rgb':
loader = VideoLoaderHDF5()
else:
loader = VideoLoaderFlowHDF5()
video_path_formatter = (lambda root_path, label, video_id: root_path /
label / f'{video_id}.hdf5')
val_data = VideoDataset(
args.video_path,
args.annotation_path,
'validation',
spatial_transform=spatial_transform,
temporal_transform=temporal_transform,
# target_transform=target_transform,
video_loader=loader,
video_path_formatter=video_path_formatter)
val_loader = torch.utils.data.DataLoader(val_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=2,
pin_memory=True,
sampler=None,
worker_init_fn=worker_init_fn)
# assert args.inference_subset in ['train', 'val', 'test']
if args.file_type == 'jpg':
assert args.input_type == 'rgb', 'flow input is supported only when input type is hdf5.'
if get_image_backend() == 'accimage':
from dataset.loader import ImageLoaderAccImage
loader = VideoLoader(image_name_formatter, ImageLoaderAccImage())
else:
loader = VideoLoader(image_name_formatter)
video_path_formatter = (
lambda root_path, label, video_id: root_path / label / video_id)
else:
if args.input_type == 'rgb':
loader = VideoLoaderHDF5()
else:
loader = VideoLoaderFlowHDF5()
video_path_formatter = (lambda root_path, label, video_id: root_path /
label / f'{video_id}.hdf5')
inference_data = VideoDataset(
args.video_path,
args.annotation_path,
'testing',
spatial_transform=spatial_transform,
temporal_transform=temporal_transform,
# target_transform=target_transform,
video_loader=loader,
video_path_formatter=video_path_formatter,
target_type=['video_id', 'segment'])
inference_loader = torch.utils.data.DataLoader(
inference_data,
batch_size=args.batch_size,
shuffle=False,
num_workers=2,
pin_memory=True,
worker_init_fn=worker_init_fn)
return train_loader, val_loader, inference_loader
def default_loader(path, *, n_channel):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path, n_channel=n_channel)
def image_loader(path):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path)
def default_loader(path, is_gam=False):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path, is_gam)
else:
return pil_loader(path, is_gam)
def default_loader(path: str) -> Any:
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path)
def default_loader(path, mode="RGB"):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path, mode)
def __readImg(self, path):
from torchvision import get_image_backend
if get_image_backend() == "accimage":
return self.__accimageLoader(path)
else:
return self.__pilLoader(path)
def default_loader(path):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return accimage_loader(path)
else:
return pil_loader(path)
def default_loader(self, path):
from torchvision import get_image_backend
if get_image_backend() == 'accimage':
return self.accimage_loader(path)
else:
return self.pil_loader(path)
