def load_model(path, stream_type):
checkpoint = torch.load(path, map_location=DEVICE)
# dataset=None
if stream_type == 'rgb':
model = checkpoint['model_config']['model']
# dataset = checkpoint['model_config']['dataset']
featureExtract = checkpoint['model_config']['featureExtract']
model_ = ResNetRGB(num_classes=2, model_name=model, feature_extract=featureExtract)
model_ = model_.build_model()
else:
model = checkpoint['model_config']['model']
numDynamicImages = checkpoint['model_config']['numDynamicImages']
joinType = checkpoint['model_config']['joinType']
featureExtract = checkpoint['model_config']['featureExtract']
model_, _ = initialize_model(model_name=model,
num_classes=2,
feature_extract=featureExtract,
numDiPerVideos=numDynamicImages,
joinType=joinType,
use_pretrained=True)
model_.to(DEVICE)
# print(model_)
if DEVICE == 'cuda:0':
model_.load_state_dict(checkpoint['model_state_dict'], strict=False)
else:
model_.load_state_dict(checkpoint['model_state_dict'])
return model_
def load_model(modelPath, stream_type):
checkpoint = torch.load(modelPath, map_location=DEVICE)
args = dict()
if stream_type == 'rgb':
model = checkpoint['model_config']['model']
# dataset = checkpoint['model_config']['dataset']
args['featureExtract'] = checkpoint['model_config']['featureExtract']
args['frameIdx'] = checkpoint['model_config']['frameIdx']
model_ = ResNetRGB(num_classes=2,
model_name=model,
feature_extract=args['featureExtract'])
model_ = model_.build_model()
else:
# checkpoint = torch.load(modelPath, map_location=DEVICE)
model = checkpoint['model_config']['model']
args['numDynamicImages'] = checkpoint['model_config'][
'numDynamicImages']
args['joinType'] = checkpoint['model_config']['joinType']
args['freezeConvLayers'] = checkpoint['model_config'][
'freezeConvLayers']
args['videoSegmentLength'] = checkpoint['model_config'][
'segmentLength']
args['overlapping'] = checkpoint['model_config']['overlap']
args['frameSkip'] = checkpoint['model_config']['frameSkip']
args['skipInitialFrames'] = checkpoint['model_config'][
'skipInitialFrames']
args['useKeyframes'] = checkpoint['model_config']['useKeyframes']
args['windowLen'] = checkpoint['model_config']['windowLen']
model_, _ = initialize_model(model_name=model,
num_classes=2,
freezeConvLayers=args['freezeConvLayers'],
numDiPerVideos=args['numDynamicImages'],
joinType=args['joinType'],
use_pretrained=True)
model_.to(DEVICE)
# print(model_)
if DEVICE == 'cuda:0':
model_.load_state_dict(checkpoint['model_state_dict'], strict=False)
else:
model_.load_state_dict(checkpoint['model_state_dict'])
return model_, args
def __anomaly_main__():
parser = argparse.ArgumentParser()
parser.add_argument("--classifier", type=str)
# parser.add_argument("--modelType", type=str)
parser.add_argument("--batchSize", type=int, default=8)
parser.add_argument("--numEpochs", type=int, default=10)
parser.add_argument("--numWorkers", type=int, default=4)
parser.add_argument("--areaL", type=float, default=8)
parser.add_argument("--smoothL", type=float, default=0.5)
parser.add_argument("--preserverL", type=float, default=0.3)
parser.add_argument("--areaPowerL", type=float, default=0.3)
# parser.add_argument("--numDiPerVideos", type=int)
# parser.add_argument("--segmentLen", type=int)
parser.add_argument("--saveCheckpoint",
type=lambda x: (str(x).lower() == 'true'),
default=False)
args = parser.parse_args()
num_classes = 2
class_checkpoint = load_torch_checkpoint(args.classifier)
train_x, train_y, train_numFrames, mytransfroms = base_dataset(
class_checkpoint['model_config']['dataset'], fold=1)
print(class_checkpoint['model_config'], '_epoch=',
class_checkpoint['epoch'], '_fold=', class_checkpoint['fold'],
'_val_acc=', class_checkpoint['val_acc'], '_val_loss=',
class_checkpoint['val_loss'])
regularizers = {
'area_loss_coef': args.areaL,
'smoothness_loss_coef': args.smoothL,
'preserver_loss_coef': args.preserverL,
'area_loss_power': args.areaPowerL
}
default_args = {
'X': train_x,
'y': train_y,
'numFrames': train_numFrames,
'transform': mytransfroms['train'],
'NDI': class_checkpoint['model_config']['numDynamicImages'],
'videoSegmentLength':
class_checkpoint['model_config']['segmentLength'],
'positionSegment': 'begin',
'overlapping': class_checkpoint['model_config']['overlap'],
'frameSkip': 0, #class_checkpoint['model_config']['frameSkip']
'skipInitialFrames':
class_checkpoint['model_config']['skipInitialFrames'],
'batchSize': args.batchSize,
'shuffle': True,
'numWorkers': args.numWorkers,
'pptype': None,
'modelType': class_checkpoint['model_config']['modelType']
}
train_dt_loader = MyDataloader(default_args)
mask_model = build_saliency_model(num_classes)
mask_model.to(DEVICE)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(mask_model.parameters())
# classifier = torch.load(black_box_model)
classifier_model, _ = initialize_model(
model_name=class_checkpoint['model_config']['modelType'],
num_classes=2,
feature_extract=False,
numDiPerVideos=class_checkpoint['model_config']['numDynamicImages'],
joinType=class_checkpoint['model_config']['joinType'],
use_pretrained=True)
classifier_model.load_state_dict(class_checkpoint['model_state_dict'])
classifier_model.to(DEVICE)
classifier_model.eval()
checkpoint_path = None
if args.saveCheckpoint:
checkpoint_path = 'MaskModel_bbone={}_Dts={}_NDI-len={}-{}_AreaLoss={}_SmoothLoss={}_PreservLoss={}_AreaLoss2={}_epochs={}'.format(
class_checkpoint['model_config']['modelType'],
class_checkpoint['model_config']['dataset'],
class_checkpoint['model_config']['numDynamicImages'],
class_checkpoint['model_config']['segmentLength'], args.areaL,
args.smoothL, args.preserverL, args.areaPowerL, args.numEpochs)
checkpoint_path = os.path.join(constants.PATH_RESULTS, 'MASKING',
'checkpoints', checkpoint_path)
train(
mask_model=mask_model,
criterion=criterion,
optimizer=optimizer,
regularizers=regularizers,
classifier_model=classifier_model,
num_epochs=args.numEpochs,
dataloader=train_dt_loader.dataloader,
numDynamicImages=class_checkpoint['model_config']['numDynamicImages'],
checkpoint_path=checkpoint_path,
fold=class_checkpoint['fold'])
def skorch_a(args):
shuffle = True
if args.dataset[0] == 'rwf-2000':
datasetAll, labelsAll = [], []
else:
datasetAll, labelsAll, numFramesAll, transforms = base_dataset(
args.dataset[0], input_size=args.inputSize)
cv_test_accs = []
cv_test_losses = []
cv_final_epochs = []
# patience = 5
folds_number = 5
fold = 0
checkpoint_path = None
config = None
print(args.dataset)
wandb_run = wandb.init('Violence-Detection-2')
for train_idx, test_idx in customize_kfold(n_splits=folds_number,
dataset=args.dataset[0],
X=datasetAll,
y=labelsAll,
shuffle=shuffle):
fold = fold + 1
print("**************** Fold:{}/{} ".format(fold, folds_number))
if args.dataset[0] == 'rwf-2000':
train_x, train_y, train_numFrames, test_x, test_y, test_numFrames, transforms = base_dataset(
args.dataset[0], input_size=args.inputSize)
# print(len(train_x), len(train_y), len(train_numFrames), len(test_x), len(test_y), len(test_numFrames))
else:
train_x, train_y, test_x, test_y = None, None, None, None
train_x = list(itemgetter(*train_idx)(datasetAll))
train_y = list(itemgetter(*train_idx)(labelsAll))
train_numFrames = list(itemgetter(*train_idx)(numFramesAll))
test_x = list(itemgetter(*test_idx)(datasetAll))
test_y = list(itemgetter(*test_idx)(labelsAll))
test_numFrames = list(itemgetter(*test_idx)(numFramesAll))
print('Label distribution:')
print('Train=', Counter(train_y))
# print('Val=', Counter(val_y))
print('Test=', Counter(test_y))
if args.useValSplit:
train_x, val_x, train_numFrames, val_numFrames, train_y, val_y = train_test_split(
train_x,
train_numFrames,
train_y,
test_size=0.2,
stratify=train_y,
random_state=1)
#Label distribution
# print('Label distribution:')
# print('Train=', Counter(train_y))
print('Val=', Counter(val_y))
# print('Test=', Counter(test_y))
val_dataset = ViolenceDataset(
videos=val_x,
labels=val_y,
numFrames=val_numFrames,
spatial_transform=transforms['val'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
train_dataset = ViolenceDataset(
videos=train_x,
labels=train_y,
numFrames=train_numFrames,
spatial_transform=transforms['train'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
test_dataset = ViolenceDataset(
videos=test_x,
labels=test_y,
numFrames=test_numFrames,
spatial_transform=transforms['val'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
if not args.useValSplit:
val_dataset = test_dataset
# from MODELS.ViolenceModels import ResNet
# PretrainedModel = ResNet(num_classes=2,
# numDiPerVideos=args.numDynamicImagesPerVideo,
# model_name=args.modelType,
# joinType=args.joinType,
# freezeConvLayers=args.freezeConvLayers)
PretrainedModel = initialize_model(
model_name=args.modelType,
num_classes=2,
freezeConvLayers=args.freezeConvLayers,
numDiPerVideos=args.numDynamicImagesPerVideo,
joinType=args.joinType,
pretrained=args.pretrained)
lrscheduler = LRScheduler(policy='StepLR', step_size=7, gamma=0.1)
freezer = Freezer(lambda x: not x.startswith('fc8'))
# writer = SummaryWriter()
# ts = TensorBoard(writer)
# wandb_run = wandb.init('Violence-Detection-2')
# wandb.init(group='fold-'.format(fold))
wandb_run.config.update(vars(args))
if args.freezeConvLayers:
callbacks = [lrscheduler, freezer, WandbLogger(wandb_run)]
else:
callbacks = [lrscheduler, WandbLogger(wandb_run)]
if args.saveCheckpoint:
#checkpoint_path = args_2_checkpoint_path(args, fold=fold)
#cp = Checkpoint(f_params=checkpoint_path, monitor='valid_acc_best')
cp = Checkpoint(dirname='rwf-exp1', monitor='valid_acc_best')
callbacks.append(cp)
#print('checkpoint_path: ', checkpoint_path)
optimizer = optim.SGD
print('Running in: ', DEVICE)
if DEVICE == 'cpu':
net = NeuralNetClassifier(
PretrainedModel,
criterion=nn.CrossEntropyLoss,
lr=args.lr,
batch_size=args.batchSize,
max_epochs=args.numEpochs,
optimizer=optimizer,
optimizer__momentum=0.9,
iterator_train__shuffle=True,
iterator_train__num_workers=4,
iterator_valid__shuffle=True,
iterator_valid__num_workers=args.numWorkers,
train_split=predefined_split(val_dataset),
callbacks=callbacks)
else:
net = NeuralNetClassifier(
PretrainedModel,
criterion=nn.CrossEntropyLoss,
lr=args.lr,
batch_size=args.batchSize,
max_epochs=args.numEpochs,
optimizer=optimizer,
optimizer__momentum=0.9,
iterator_train__shuffle=True,
iterator_train__num_workers=4,
iterator_valid__shuffle=True,
iterator_valid__num_workers=args.numWorkers,
train_split=predefined_split(val_dataset),
callbacks=callbacks,
device=DEVICE)
net.fit(train_dataset, y=None)
## inferenceMode
if args.saveCheckpoint:
net = NeuralNetClassifier(
PretrainedModel,
criterion=nn.CrossEntropyLoss,
lr=args.lr,
batch_size=args.batchSize,
max_epochs=args.numEpochs,
optimizer=optimizer,
optimizer__momentum=0.9,
iterator_train__shuffle=True,
iterator_train__num_workers=4,
iterator_valid__shuffle=True,
iterator_valid__num_workers=args.numWorkers,
train_split=predefined_split(val_dataset),
callbacks=callbacks,
device=DEVICE)
net.initialize()
net.load_params(checkpoint=cp)
y_pred = net.predict(test_dataset)
X_test_s = SliceDataset(test_dataset)
y_test_s = SliceDataset(test_dataset, idx=1)
acc = accuracy_score(y_test_s, y_pred)
cv_test_accs.append(acc)
print('Accuracy={}'.format(acc))
# error_mask = y_pred != y_test_s
# print(error_mask)
# plot_example(X_test_s[error_mask], y_pred[error_mask], test_x)
# plot_example(X_test_s, y_test_s, test_x)
# from sklearn.model_selection import GridSearchCV
# params = {
# 'lr': [0.03, 0.02, 0.01, 0.001],
# 'max_epochs': [25, 35],
# }
# gs = GridSearchCV(net, params, refit=False, cv=3, scoring='accuracy',n_jobs=1, verbose=1)
# from skorch.helper import SliceDataset
# X_sl = SliceDataset(train_dataset, idx=0) # idx=0 is the default
# print(X_sl.shape)
# # y_sl = np.array([y for x, y in iter(train_dataset)])
# y_sl = SliceDataset(train_dataset, idx=1)
# print(y_sl.shape)
# try:
# gs.fit(X_sl, y_sl)
# except Exception as e:
# print(e)
print('CV Accuracies=', cv_test_accs)
print('Test AVG Accuracy={}'.format(np.average(cv_test_accs)))
print("Accuracy: %0.3f (+/- %0.3f)" %
(np.array(cv_test_accs).mean(), np.array(cv_test_accs).std() * 2))
def __pytorch__(args):
# args = build_args()
wandb.login()
rgb_transforms = {
'train':
torchvision.transforms.Compose([
torchvision.transforms.RandomResizedCrop(args.inputSize),
torchvision.transforms.RandomHorizontalFlip(),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
'val':
torchvision.transforms.Compose([
torchvision.transforms.Resize(args.inputSize),
torchvision.transforms.CenterCrop(args.inputSize),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
]),
}
if args.splitType == 'cam':
__weakly_localization__()
return 0
if args.splitType == 'openSet-train' or args.splitType == 'openSet-test':
openSet_experiments(mode=args.splitType, args=args)
return 0
input_size = 224
shuffle = True
if args.dataset[0] == 'rwf-2000':
datasetAll, labelsAll = [], []
else:
datasetAll, labelsAll, numFramesAll, transforms = base_dataset(
args.dataset[0], input_size=args.inputSize)
print('====> Loaded all dataset? X:{}, y:{}, numFrames:{}'.format(
len(datasetAll), len(labelsAll), len(numFramesAll)))
cv_test_accs = []
cv_test_losses = []
cv_final_epochs = []
# patience = 5
folds_number = 5
fold = 0
checkpoint_path = None
config = None
print(args.dataset)
# for train_idx, test_idx in customize_kfold(n_splits=folds_number, dataset=args.dataset[0], X_len=len(datasetAll), shuffle=shuffle):
template = 'Fold: {}, epoch: {}/{}, train_loss: {:.5f}, train_acc: {:.5f}, test_loss: {:.5f}, test_acc: {:.5f}'
for train_idx, test_idx in customize_kfold(n_splits=folds_number,
dataset=args.dataset[0],
X=datasetAll,
y=labelsAll,
shuffle=shuffle):
fold = fold + 1
wandb_run = wandb.init(project="pytorch-violencedetection2")
wandb_run.config.update(vars(args))
print("**************** Fold:{}/{} ".format(fold, folds_number))
if args.dataset[0] == 'rwf-2000':
train_x, train_y, train_numFrames, test_x, test_y, test_numFrames, transforms = base_dataset(
args.dataset[0], input_size=args.inputSize)
print(len(train_x), len(train_y), len(train_numFrames),
len(test_x), len(test_y), len(test_numFrames))
else:
train_x, train_y, test_x, test_y = None, None, None, None
train_x = list(itemgetter(*train_idx)(datasetAll))
train_y = list(itemgetter(*train_idx)(labelsAll))
train_numFrames = list(itemgetter(*train_idx)(numFramesAll))
test_x = list(itemgetter(*test_idx)(datasetAll))
test_y = list(itemgetter(*test_idx)(labelsAll))
test_numFrames = list(itemgetter(*test_idx)(numFramesAll))
test_dataset = ViolenceDataset(
videos=test_x,
labels=test_y,
numFrames=test_numFrames,
spatial_transform=transforms['val'],
rgb_transform=rgb_transforms['val'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
print('Label distribution:')
print('Train=', Counter(train_y))
print('Test=', Counter(test_y))
if args.useValSplit:
train_x, val_x, train_numFrames, val_numFrames, train_y, val_y = train_test_split(
train_x,
train_numFrames,
train_y,
test_size=0.2,
stratify=train_y,
random_state=1)
print('Val=', Counter(val_y))
val_dataset = ViolenceDataset(
videos=val_x,
labels=val_y,
numFrames=val_numFrames,
spatial_transform=transforms['val'],
rgb_transform=rgb_transforms['val'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
train_dataset = ViolenceDataset(
videos=train_x,
labels=train_y,
numFrames=train_numFrames,
spatial_transform=transforms['train'],
rgb_transform=rgb_transforms['train'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
test_dataset = ViolenceDataset(
videos=test_x,
labels=test_y,
numFrames=test_numFrames,
spatial_transform=transforms['val'],
rgb_transform=rgb_transforms['val'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen,
dataset=args.dataset[0])
if not args.useValSplit:
val_dataset = test_dataset
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batchSize,
shuffle=True,
num_workers=args.numWorkers)
val_dataloader = torch.utils.data.DataLoader(
val_dataset,
batch_size=args.batchSize,
shuffle=True,
num_workers=args.numWorkers)
dataloaders = {'train': train_dataloader, 'val': val_dataloader}
# if args.pretrained is not None:
# model = load_model(args.pretrained)
# else:
# model = initialize_model(model_name=args.modelType,
# num_classes=2,
# freezeConvLayers=args.freezeConvLayers,
# numDiPerVideos=args.numDynamicImagesPerVideo,
# joinType=args.joinType,
# pretrained=args.pretrained)
model = initialize_model(model_name=args.modelType,
num_classes=2,
freezeConvLayers=args.freezeConvLayers,
numDiPerVideos=args.numDynamicImagesPerVideo,
joinType=args.joinType,
pretrained=args.pretrained)
model.to(DEVICE)
if args.modelType == 'c3d_v2':
from MODELS.c3d_v2 import get_1x_lr_params, get_10x_lr_params
params_to_update = [{
'params': get_1x_lr_params(model),
'lr': args.lr
}, {
'params': get_10x_lr_params(model),
'lr': args.lr * 10
}]
optimizer = optim.SGD(params_to_update,
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
# exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)
else:
params_to_update = verifiParametersToTrain(model,
args.freezeConvLayers,
printLayers=False)
if args.optimizer == 'adam':
optimizer = optim.Adam(params_to_update,
lr=args.lr,
betas=(0.9, 0.999),
eps=1e-08,
weight_decay=1e-5)
else:
optimizer = optim.SGD(params_to_update,
lr=args.lr,
momentum=0.9)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer,
step_size=10,
gamma=0.1)
criterion = nn.CrossEntropyLoss()
wandb.watch(model, log="all")
# log_dir = os.path.join(constants.PATH_RESULTS, args.dataset.upper(), 'tensorboard-runs', experimentConfig_str)
# writer = SummaryWriter(log_dir)
# if args.saveCheckpoint:
# checkpoint_path = args_2_checkpoint_path(args, fold=fold)
phases = ['train', 'val']
model, best_acc, val_loss_min, best_epoch = train_model(
model,
dataloaders,
criterion,
optimizer,
exp_lr_scheduler,
num_epochs=args.numEpochs,
patience=args.patience,
fold=fold,
path=checkpoint_path,
phases=phases,
model_config=config,
template=template)
cv_test_accs.append(best_acc.item())
cv_test_losses.append(val_loss_min)
cv_final_epochs.append(best_epoch)
print('CV Accuracies=', cv_test_accs)
print('CV Losses=', cv_test_losses)
print('CV Epochs=', cv_final_epochs)
print('Test AVG Accuracy={}, Test AVG Loss={}'.format(
np.average(cv_test_accs), np.average(cv_test_losses)))
print("Accuracy: %0.3f (+/- %0.3f), Losses: %0.3f" %
(np.array(cv_test_accs).mean(), np.array(cv_test_accs).std() * 2,
np.array(cv_test_losses).mean()))
def openSet_experiments(mode, args):
# parser = argparse.ArgumentParser()
# parser.add_argument("--mode",type=str)
if mode == 'openSet-train':
# datasets = args.splitType[1:]
# print(datasets)
datasetAll, labelsAll, numFramesAll, transforms = [], [], [], []
for dt in args.dataset:
print(dt)
x, y, num, tr = base_dataset(dt)
datasetAll += x
labelsAll += y
numFramesAll += num
transforms.append(tr)
combined = list(zip(datasetAll, labelsAll, numFramesAll))
random.shuffle(combined)
datasetAll[:], labelsAll[:], numFramesAll[:] = zip(*combined)
train_dataset = ViolenceDataset(
dataset=datasetAll,
labels=labelsAll,
numFrames=numFramesAll,
spatial_transform=transforms[0]['train'],
numDynamicImagesPerVideo=args.numDynamicImagesPerVideo,
videoSegmentLength=args.videoSegmentLength,
positionSegment=args.positionSegment,
overlaping=args.overlapping,
frame_skip=args.frameSkip,
skipInitialFrames=args.skipInitialFrames,
ppType=None,
useKeyframes=args.useKeyframes,
windowLen=args.windowLen)
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batchSize,
shuffle=True,
num_workers=args.numWorkers)
dataloaders = {'train': train_dataloader}
model, _ = initialize_model(
model_name=args.modelType,
num_classes=2,
freezeConvLayers=args.freezeConvLayers,
numDiPerVideos=args.numDynamicImagesPerVideo,
joinType=args.joinType,
use_pretrained=True)
model.to(DEVICE)
params_to_update = verifiParametersToTrain(model,
args.freezeConvLayers,
printLayers=True)
# print(params_to_update)
optimizer = optim.SGD(params_to_update, lr=0.001, momentum=0.9)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer,
step_size=7,
gamma=0.1)
criterion = nn.CrossEntropyLoss()
fold = 0
checkpoint_path = None
config = None
if args.saveCheckpoint:
config = {
'dataset': args.dataset,
'model': args.modelType,
'numEpochs': args.numEpochs,
'freezeConvLayers': args.freezeConvLayers,
'numDynamicImages': args.numDynamicImagesPerVideo,
'segmentLength': args.videoSegmentLength,
'frameSkip': args.frameSkip,
'skipInitialFrames': args.skipInitialFrames,
'overlap': args.overlapping,
'joinType': args.joinType,
'log_dir': None,
'useKeyframes': args.useKeyframes,
'windowLen': args.windowLen
}
ss = ""
for (key, val) in config.items():
if key != 'log_dir':
ss = ss + "_{!s}={!r}".format(key, val)
ss = ss.replace("\'", "")
# print(ss)
checkpoint_path = os.path.join(
constants.PATH_RESULTS, 'OPENSET', 'checkpoints',
'DYN_Stream-{}-fold={}'.format(ss, fold))
phases = ['train']
model, best_acc, val_loss_min, best_epoch = train_model(
model,
dataloaders,
criterion,
optimizer,
num_epochs=args.numEpochs,
patience=args.patience,
fold=fold,
path=checkpoint_path,
model_config=config,
phases=phases,
metric_to_track='train-loss')
elif mode == 'openSet-test':
## Load model
checkpoint = torch.load(args.modelPath, map_location=DEVICE)
model = checkpoint['model_config']['model']
numDynamicImages = checkpoint['model_config']['numDynamicImages']
joinType = checkpoint['model_config']['joinType']
freezeConvLayers = checkpoint['model_config']['freezeConvLayers']
videoSegmentLength = checkpoint['model_config']['segmentLength']
overlapping = checkpoint['model_config']['overlap']
frameSkip = checkpoint['model_config']['frameSkip']
skipInitialFrames = checkpoint['model_config']['skipInitialFrames']
useKeyframes = checkpoint['model_config']['useKeyframes']
windowLen = checkpoint['model_config']['windowLen']
model_, _ = initialize_model(model_name=model,
num_classes=2,
freezeConvLayers=freezeConvLayers,
numDiPerVideos=numDynamicImages,
joinType=joinType,
use_pretrained=True)
model_.to(DEVICE)
# print(model_)
if DEVICE == 'cuda:0':
model_.load_state_dict(checkpoint['model_state_dict'],
strict=False)
else:
model_.load_state_dict(checkpoint['model_state_dict'])
datasetAll, labelsAll, numFramesAll, transforms = base_dataset(
args.testDataset)
test_dataset = ViolenceDataset(
dataset=datasetAll,
labels=labelsAll,
numFrames=numFramesAll,
spatial_transform=transforms['val'],
numDynamicImagesPerVideo=numDynamicImages,
videoSegmentLength=videoSegmentLength,
positionSegment=None,
overlaping=overlapping,
frame_skip=frameSkip,
skipInitialFrames=skipInitialFrames,
ppType=None,
useKeyframes=useKeyframes,
windowLen=windowLen)
test_dataloader = torch.utils.data.DataLoader(test_dataset,
batch_size=8,
shuffle=True,
num_workers=4)
test_model(model_, test_dataloader)