def TestOnlySpatialNet():
spa_model = resnet152_SpatialNet().cuda().eval()
if spa_model_save_file is not None:
spa_model.load_state_dict(torch.load(spa_model_save_file))
print('load spa_model success!')
spa_model.eval()
dsl = test_UCF0101_Spatial()
def gen():
return GenVariables_Spatial(dsl, batchsize=16)
loops = 50
correct_1 = 0
correct_5 = 0
correct_10 = 0
for i in range(loops):
images, labels = gen()
pred = spa_model(images)
# pred = F.softmax(pred)
labels = labels.cpu()
pred = pred.cpu()
acc = accuracy(pred, labels, topk=(1, 5, 10))
correct_1 += acc[0]
correct_5 += acc[1]
correct_10 += acc[2]
print(acc)
print('acc@1:', correct_1 / loops)
print('acc@5:', correct_5 / loops)
print('acc@10:', correct_10 / loops)
'''
# for i in range(worker):
# self.ts.append(threading.Thread(target=self.pr,name='Producter_{}'.format(i)))
# for i in range(worker):
# self.ts[i].start()
#
# def pr(self):
# while True:
# self.q.put(self.Gen(self.dsl,self.batchsize))
#
# def Get(self):
# imgs,labels = self.q.get()
# return imgs.cuda(),labels.cuda()
#
# def Close(self):
# '''
# May Be Need To Stop Threads
# :return:
# '''
# pass
if __name__ == '__main__':
dsl = test_UCF101_C3D()
dsl = test_UCF0101_Spatial()
dsl = test_UCF0101_Temporal()
itemss = random.choices(dsl, k=3)
pq = PictureQueue(dsl, GenVariables_C3D, 3)
pa, pb = pq.Get()
loops = 2000
TEST = 'S'
if TEST == 'T':
pq_train = PictureQueue(dsl=train_UCF0101_Temporal(),
Gen=GenVariables_Temporal,
batchsize=batchsize)
pq_test = PictureQueue(dsl=test_UCF0101_Temporal(),
Gen=GenVariables_Temporal,
batchsize=batchsize)
elif TEST == 'S':
pq_train = PictureQueue(dsl=train_UCF0101_Spatial(),
Gen=GenVariables_Spatial,
batchsize=batchsize)
pq_test = PictureQueue(dsl=test_UCF0101_Spatial(),
Gen=GenVariables_Spatial,
batchsize=batchsize)
elif TEST == 'C3D':
pq_train = PictureQueue(dsl=train_UCF101_C3D(),
Gen=GenVariables_C3D,
batchsize=batchsize)
pq_test = PictureQueue(dsl=test_UCF101_C3D(),
Gen=GenVariables_C3D,
batchsize=batchsize)
print('before:', time.asctime())
a, b = GenVariables_Temporal(train_UCF0101_Temporal(), batchsize=batchsize)
print('after:', time.asctime())
cnt = 0
def DPN92_SpatialNet_Run():
epochs = 121
loops = 2001
learningrate = 0.01
attenuation = 0.1
model = dpn92(num_classes=101).cuda()
if Config.LOAD_SAVED_MODE_PATH is not None:
import types
model.try_to_load_state_dict = types.MethodType(try_to_load_state_dict, model)
model.try_to_load_state_dict(torch.load(Config.LOAD_SAVED_MODE_PATH))
print('LOAD {} done!'.format(Config.LOAD_SAVED_MODE_PATH))
lossfunc = nn.CrossEntropyLoss()
optim = torch.optim.Adam(model.parameters(), lr=learningrate)
pq_train = PictureQueue(dsl=train_UCF0101_Spatial(), Gen=GenVariables_Spatial, batchsize=batchsize, worker=10)
pq_test = PictureQueue(dsl=test_UCF0101_Spatial(), Gen=GenVariables_Spatial, batchsize=batchsize, worker=3)
cnt = 0
for epoch in range(epochs):
for l in range(loops):
cnt += 1
imgs, labels = pq_train.Get()
model.zero_grad()
pred = model(imgs)
loss = lossfunc(pred, labels)
logger.scalar_summary('DPN92/Spatial/train_loss', loss.data[0], cnt)
loss.backward()
optim.step()
print('Spatial epoch: {} cnt: {} loss: {}'.format(epoch, cnt, loss.data[0]))
if cnt % 25 == 0:
model.eval()
imgs, labels = pq_test.Get()
pred = model(imgs)
loss = lossfunc(pred, labels)
logger.scalar_summary('DPN92/Spatial/test_loss', loss.data[0], cnt)
# acc
acc = accuracy(pred, labels, topk=(1, 5, 10))
logger.scalar_summary('DPN92/Spatial/test_acc@1', acc[0], cnt)
logger.scalar_summary('DPN92/Spatial/test_acc@5', acc[1], cnt)
logger.scalar_summary('DPN92/Spatial/test_acc@10', acc[2], cnt)
imgs, labels = pq_train.Get()
pred = model(imgs)
acc = accuracy(pred, labels, topk=(1, 5, 10))
logger.scalar_summary('DPN92/Spatial/train_acc@1', acc[0], cnt)
logger.scalar_summary('DPN92/Spatial/train_acc@5', acc[1], cnt)
logger.scalar_summary('DPN92/Spatial/train_acc@10', acc[2], cnt)
model.train()
if cnt % 2000 == 0:
savefile = savepath + 'DPN92_Spatial_{:02d}.pt'.format(epoch % 50)
print('Spatial save model to {}'.format(savefile))
torch.save(model.state_dict(), savefile)
if epoch in [5, 10, 20, 50, 60]:
learningrate = learningrate * attenuation
optim = torch.optim.Adam(model.parameters(), lr=learningrate)
def VGG_Spatial_Net_Run():
epochs = 80
loops = 2000
learningrate = 0.001
attenuation = 0.1
model = VGG_Spatial_Net(pretrained=False, dropout1=0.8, dropout2=0.7).cuda()
if Config.LOAD_SAVED_MODE_PATH is not None:
import types
model.try_to_load_state_dict = types.MethodType(try_to_load_state_dict, model)
model.try_to_load_state_dict(torch.load(Config.LOAD_SAVED_MODE_PATH))
print('LOAD {} done!'.format(Config.LOAD_SAVED_MODE_PATH))
lossfunc = nn.CrossEntropyLoss()
optim = torch.optim.SGD(model.parameters(), lr=learningrate, momentum=0.9)
cnt = 0
pq_train = PictureQueue(dsl=train_UCF0101_Spatial(), Gen=GenVariables_Spatial, batchsize=batchsize)
pq_test = PictureQueue(dsl=test_UCF0101_Spatial(), Gen=GenVariables_Spatial, batchsize=batchsize)
for epoch in range(epochs):
for l in range(loops):
cnt += 1
imgs, labels = pq_train.Get()
model.zero_grad()
pred = model(imgs)
loss = lossfunc(pred, labels)
logger.scalar_summary('Spatial/train_loss', loss.data[0], cnt)
loss.backward()
optim.step()
print('Spatial epoch: {} cnt: {} loss: {}'.format(epoch, cnt, loss.data[0]))
if cnt % 20 == 0:
imgs, labels = pq_test.Get()
pred = model.inference(imgs)
loss = lossfunc(pred, labels)
logger.scalar_summary('Spatial/test_loss', loss.data[0], cnt)
acc = accuracy(pred, labels, topk=(1, 5, 10))
logger.scalar_summary('Spatial/test_acc@1', acc[0], cnt)
logger.scalar_summary('Spatial/test_acc@5', acc[1], cnt)
logger.scalar_summary('Spatial/test_acc@10', acc[2], cnt)
imgs, labels = pq_train.Get()
pred = model.inference(imgs)
acc = accuracy(pred, labels, topk=(1, 5, 10))
logger.scalar_summary('Spatial/train_acc@1', acc[0], cnt)
logger.scalar_summary('Spatial/train_acc@5', acc[1], cnt)
logger.scalar_summary('Spatial/train_acc@10', acc[2], cnt)
if cnt % 2000 == 0:
savefile = savepath + 'VGG_Spatial_EX1_{:02d}.pt'.format(epoch % 50)
print('Spatial save model to {}'.format(savefile))
torch.save(model.state_dict(), savefile)
if epoch in [10, 20, 50, 60]:
learningrate = learningrate * attenuation
optim = torch.optim.SGD(model.parameters(), lr=learningrate, momentum=0.9, )