workspace.FeedBlob(key, wts[key])

workspace.FeedBlob('data', data)
workspace.RunNet(c2_net.net.Proto().name)

c2_blobs = {key: workspace.FetchBlob(key) for key in workspace.Blobs()}

#-----------------------------------------------------------------------------------------------#
torch.backends.cudnn.enabled = False
from models import resnet

data = torch.from_numpy(data).cuda()

# load pretrained weights
if args.model=='r50':
    pth_net = resnet.i3_res50(num_classes=400)
    key_map = torch.load('pretrained/i3d_r50_kinetics.pth.keymap')
elif args.model=='r50_nl':
    pth_net = resnet.i3_res50_nl(num_classes=400)
    key_map = torch.load('pretrained/i3d_r50_nl_kinetics.pth.keymap')
key_map = {'.'.join(k.split('.')[:-1]): '_'.join(v.split('_')[:-1]) for k, v in key_map.items()}
pth_net.cuda().eval()
    
def hook(module, input, output):
    setattr(module, "_value_hook", output)

for name, module in pth_net.named_modules():
    module.register_forward_hook(hook)

pth_net({'frames':data})
Example #2
0
        ['%s: %.3f' % (k, v.value()[0]) for k, v in loss_meters.items()])
    print(log_str)


#----------------------------------------------------------------------------------------------------------------------------------------#
from data import kinetics
from models import resnet

if args.mode == 'video':
    testset = kinetics.KineticsMultiCrop(root='data/kinetics/',
                                         split='val',
                                         clip_len=32)
elif args.mode == 'clip':
    testset = kinetics.Kinetics(root='data/kinetics/',
                                split='val',
                                clip_len=32)

testloader = torch.utils.data.DataLoader(testset,
                                         batch_size=args.batch_size,
                                         shuffle=False,
                                         num_workers=8)

net = resnet.i3_res50(num_classes=len(testset.labels))
net.cuda()

if args.parallel:
    net = nn.DataParallel(net)

with torch.no_grad():
    test()
Example #3
0
def get_model(
    num_classes,
    model_name='TSN',
    freeze_layers=True,
    model_path=None,
):
    class_counts = (125, 352)
    segment_count = 8
    base_model = 'resnet50'
    if model_name == 'BLV':
        backbone_setting = {
            'dropout': 0.5,
            'pretrained': True,
            'alpha': 2,
            'depth': 101,
            'beta': 4,
            'input_channels': 3,
            'num_classes': 174,
            'dataset': 'st2stv2',
            'groups': 64,
            'imagenet_blnet_pretrained': False,
            'blending_frames': 3
        }
        net = bLVNet_TAM(backbone_setting)
    elif model_name == 'slowfast':
        args = parse_args()
        cfg = load_config(args)
        cfg.NUM_GPUS = 1
        cfg.TRAIN.CHECKPOINT_FILE_PATH = "SLOWFAST_4x16_R50.pkl"
        net = build_model(cfg)
    elif model_name == 'TSM':
        net = get_tsm(num_classes)
        # net = torch.hub.load(repo, 'TSM', class_counts, segment_count, 'RGB',
        #                      base_model=base_model,
        #                      pretrained='epic-kitchens')
    elif model_name == 'I3D':
        net = resnet.i3_res50(400)
    else:
        net = torch.hub.load(repo,
                             model_name,
                             class_counts,
                             segment_count,
                             'RGB',
                             base_model=base_model,
                             pretrained='epic-kitchens',
                             force_reload=True)
    if freeze_layers:
        for param in net.parameters():
            param.requires_grad = False

    if model_name == 'TSN':  # or model_name == 'TSM':
        net.fc_verb = torch.nn.Linear(2048, num_classes)
    elif model_name == 'TRN':
        net.consensus.classifiers[0] = torch.nn.Linear(512, num_classes)
    elif model_name == 'BLV':
        net.new_fc = torch.nn.Linear(2048, num_classes)
    elif model_name == 'slowfast':
        net.head.projection = torch.nn.Linear(2304, num_classes)
        net.head.act = None
    elif model_name == 'I3D':
        net.fc = torch.nn.Linear(2048, num_classes)
    elif model_name == 'TSM':
        net.new_fc = torch.nn.Linear(2048, num_classes)

    if model_path is not None:
        load_model(net, model_path)

    if model_name == 'BLV':
        for param in net.baseline_model.layer4.parameters():
            param.requires_grad = True
    elif model_name in ['TRN', 'TSN', 'TSM']:
        for param in net.base_model.layer4.parameters():
            param.requires_grad = True
    elif model_name == 'I3D':
        for param in net.layer4.parameters():
            param.requires_grad = True

    use_gpu = torch.cuda.is_available()
    if use_gpu:
        net = net.cuda()
    return net
                  encoding='latin')['blobs']
for key in wts:
    if type(wts[key]) == np.ndarray:
        workspace.FeedBlob(key, wts[key])

workspace.FeedBlob('data', data)
workspace.RunNet(c2_net.net.Proto().name)

c2_blobs = {key: workspace.FetchBlob(key) for key in workspace.Blobs()}

#-----------------------------------------------------------------------------------------------#
torch.backends.cudnn.enabled = False
from models import resnet

data = torch.from_numpy(data).cuda()
pth_net = resnet.i3_res50(num_classes=400).cuda().eval()


def hook(module, input, output):
    setattr(module, "_value_hook", output)


for name, module in pth_net.named_modules():
    module.register_forward_hook(hook)

pth_net({'frames': data})

pth_blobs = {}
for name, module in pth_net.named_modules():
    try:
        if len(name) > 0:
Example #5
0
#----------------------------------------------------------------------------------------------------------------------------------------#
from tensorboardX import SummaryWriter
writer = SummaryWriter('%s/tb.log' % args.cv_dir)

from data import kinetics
from models import resnet

trainset = kinetics.Kinetics(root='data/kinetics/', split='train', clip_len=32)
trainloader = torch.utils.data.DataLoader(trainset,
                                          batch_size=args.batch_size,
                                          shuffle=True,
                                          num_workers=args.workers,
                                          pin_memory=True)

net = resnet.i3_res50(len(testset.verbs))
net.cuda()

optim_params = list(filter(lambda p: p.requires_grad, net.parameters()))
print('Optimizing %d paramters' % len(optim_params))
optimizer = optim.SGD(optim_params, lr=args.lr, weight_decay=args.weight_decay)

start_iter = 0
if args.load:
    checkpoint = torch.load(args.load, map_location='cpu')
    start_iter = checkpoint['iter']
    net.load_state_dict(checkpoint['net'])
    optimizer.load_state_dict(checkpoint['optimizer'])
    print('Loaded checkpoint from %s' % os.path.basename(args.load))

if args.parallel: