Change to the CPU version

common/inference_3d.py

@@ -21,7 +21,7 @@ def get_varialbe(target):
     var = []
 
     for i in range(num):
-        temp = Variable(target[i]).contiguous().cuda().type(torch.cuda.FloatTensor)
+        temp = Variable(target[i]).contiguous().type(torch.cuda.FloatTensor)
         var.append(temp)
 
     return var
@@ -59,12 +59,12 @@ def step(opt, dataLoader, model, optimizer=None, epoch=None):
     out = []
     for _, batch, batch_2d, batch_2d_flip in dataLoader.next_epoch():
         #[gt_3D, input_2D] = get_varialbe([batch, batch_2d])
-        #input_2D = Variable(batch_2d).contiguous().cuda().type(torch.cuda.FloatTensor)
+        #input_2D = Variable(batch_2d).contiguous().type(torch.cuda.FloatTensor)
         input_2D = torch.from_numpy(batch_2d.astype('float32'))
         input_2D_flip = torch.from_numpy(batch_2d_flip.astype('float32'))
         if torch.cuda.is_available():
-            input_2D = input_2D.cuda()
-            input_2D_flip = input_2D_flip.cuda()
+            input_2D = input_2D
+            input_2D_flip = input_2D_flip
 
         N = input_2D.size(0)
 

common/utils.py

@@ -184,7 +184,7 @@ def evaluate(test_generator, model_pos, action=None, return_predictions=False):
         for _, batch, batch_2d in test_generator.next_epoch():
             inputs_2d = torch.from_numpy(batch_2d.astype('float32'))
             if torch.cuda.is_available():
-                inputs_2d = inputs_2d.cuda()
+                inputs_2d = inputs_2d
             # Positional model
             predicted_3d_pos = model_pos(inputs_2d)
             if test_generator.augment_enabled():

joints_detectors/Alphapose/SPPE/src/main_fast_inference.py

@@ -24,7 +24,7 @@ class InferenNet(nn.Module):
     def __init__(self, kernel_size, dataset):
         super(InferenNet, self).__init__()
 
-        model = createModel().cuda()
+        model = createModel()
         print('Loading pose model from {}'.format('joints_detectors/Alphapose/models/sppe/duc_se.pth'))
         sys.stdout.flush()
         model.load_state_dict(torch.load('joints_detectors/Alphapose/models/sppe/duc_se.pth'))
@@ -52,7 +52,7 @@ class InferenNet_fast(nn.Module):
     def __init__(self, kernel_size, dataset):
         super(InferenNet_fast, self).__init__()
 
-        model = createModel().cuda()
+        model = createModel()
         print('Loading pose model from {}'.format('models/sppe/duc_se.pth'))
         model.load_state_dict(torch.load('models/sppe/duc_se.pth'))
         model.eval()

joints_detectors/Alphapose/SPPE/src/utils/img.py

@@ -333,7 +333,7 @@ def flip(x):
 
         x = torch.from_numpy(x.copy())
         if is_cuda:
-            x = x.cuda()
+            x = x
         return x
 
 

joints_detectors/Alphapose/dataloader.py

@@ -277,7 +277,7 @@ class DetectionLoader:
         self.det_inp_dim = int(self.det_model.net_info['height'])
         assert self.det_inp_dim % 32 == 0
         assert self.det_inp_dim > 32
-        self.det_model.cuda()
+        self.det_model
         self.det_model.eval()
 
         self.stopped = False
@@ -318,7 +318,7 @@ class DetectionLoader:
 
             with torch.no_grad():
                 # Human Detection
-                img = img.cuda()
+                img = img
                 prediction = self.det_model(img, CUDA=True)
                 # NMS process
                 dets = dynamic_write_results(prediction, opt.confidence,
@@ -435,7 +435,7 @@ class VideoDetectionLoader:
         self.det_inp_dim = int(self.det_model.net_info['height'])
         assert self.det_inp_dim % 32 == 0
         assert self.det_inp_dim > 32
-        self.det_model.cuda()
+        self.det_model
         self.det_model.eval()
 
         self.stream = cv2.VideoCapture(path)
@@ -493,9 +493,9 @@ class VideoDetectionLoader:
                 ht = inp[0].size(1)
                 wd = inp[0].size(2)
                 # Human Detection
-                img = Variable(torch.cat(img)).cuda()
+                img = Variable(torch.cat(img))
                 im_dim_list = torch.FloatTensor(im_dim_list).repeat(1, 2)
-                im_dim_list = im_dim_list.cuda()
+                im_dim_list = im_dim_list
 
                 prediction = self.det_model(img, CUDA=True)
                 # NMS process

joints_detectors/Alphapose/dataloader_webcam.py

@@ -119,7 +119,7 @@ class DetectionLoader:
         self.det_inp_dim = int(self.det_model.net_info['height'])
         assert self.det_inp_dim % 32 == 0
         assert self.det_inp_dim > 32
-        self.det_model.cuda()
+        self.det_model
         self.det_model.eval()
 
         self.stopped = False
@@ -144,7 +144,7 @@ class DetectionLoader:
                 self.dataloder.Q.queue.clear()
             with torch.no_grad():
                 # Human Detection
-                img = img.cuda()
+                img = img
                 prediction = self.det_model(img, CUDA=True)
                 # NMS process
                 dets = dynamic_write_results(prediction, opt.confidence,
@@ -250,7 +250,7 @@ class WebcamDetectionLoader:
         self.det_inp_dim = int(self.det_model.net_info['height'])
         assert self.det_inp_dim % 32 == 0
         assert self.det_inp_dim > 32
-        self.det_model.cuda()
+        self.det_model
         self.det_model.eval()
 
         self.stream = cv2.VideoCapture(int(webcam))
@@ -299,9 +299,9 @@ class WebcamDetectionLoader:
                 ht = inp[0].size(1)
                 wd = inp[0].size(2)
                 # Human Detection
-                img = Variable(torch.cat(img)).cuda()
+                img = Variable(torch.cat(img))
                 im_dim_list = torch.FloatTensor(im_dim_list).repeat(1,2)
-                im_dim_list = im_dim_list.cuda()
+                im_dim_list = im_dim_list
 
                 prediction = self.det_model(img, CUDA=True)
                 # NMS process

joints_detectors/Alphapose/demo.py

@@ -44,7 +44,7 @@
 #         pose_model = InferenNet_fast(4 * 1 + 1, pose_dataset)
 #     else:
 #         pose_model = InferenNet(4 * 1 + 1, pose_dataset)
-#     pose_model.cuda()
+#     pose_model
 #     pose_model.eval()
 #
 #     runtime_profile = {
@@ -79,7 +79,7 @@
 #             num_batches = datalen // batchSize + leftover
 #             hm = []
 #             for j in range(num_batches):
-#                 inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)].cuda()
+#                 inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)]
 #                 hm_j = pose_model(inps_j)
 #                 hm.append(hm_j)
 #             hm = torch.cat(hm)

joints_detectors/Alphapose/gene_npz.py

@@ -122,7 +122,7 @@ def handle_video(video_file):
         pose_model = InferenNet_fast(4 * 1 + 1, pose_dataset)
     else:
         pose_model = InferenNet(4 * 1 + 1, pose_dataset)
-    pose_model.cuda()
+    pose_model
     pose_model.eval()
     runtime_profile = {
         'dt': [],
@@ -159,7 +159,7 @@ def handle_video(video_file):
             num_batches = datalen // batchSize + leftover
             hm = []
             for j in range(num_batches):
-                inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)].cuda()
+                inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)]
                 hm_j = pose_model(inps_j)
                 hm.append(hm_j)
             hm = torch.cat(hm)

joints_detectors/Alphapose/online_demo.py

@@ -56,7 +56,7 @@ if __name__ == "__main__":
     det_inp_dim = int(det_model.net_info['height'])
     assert det_inp_dim % 32 == 0
     assert det_inp_dim > 32
-    det_model.cuda()
+    det_model
     det_model.eval()
 
     # Load pose model
@@ -65,7 +65,7 @@ if __name__ == "__main__":
         pose_model = InferenNet_fast(4 * 1 + 1, pose_dataset)
     else:
         pose_model = InferenNet(4 * 1 + 1, pose_dataset)
-    pose_model.cuda()
+    pose_model
     pose_model.eval()
 
     runtime_profile = {
@@ -88,8 +88,8 @@ if __name__ == "__main__":
             runtime_profile['ld'].append(load_time)
             with torch.no_grad():
                 # Human Detection
-                img = Variable(img).cuda()
-                im_dim_list = im_dim_list.cuda()
+                img = Variable(img)
+                im_dim_list = im_dim_list
 
                 prediction = det_model(img, CUDA=True)
                 ckpt_time, det_time = getTime(ckpt_time)
@@ -120,7 +120,7 @@ if __name__ == "__main__":
                 pt1 = torch.zeros(boxes.size(0), 2)
                 pt2 = torch.zeros(boxes.size(0), 2)
                 inps, pt1, pt2 = crop_from_dets(inp, boxes, inps, pt1, pt2)
-                inps = Variable(inps.cuda())
+                inps = Variable(inps)
 
                 hm = pose_model(inps)
                 ckpt_time, pose_time = getTime(ckpt_time)

joints_detectors/Alphapose/train_sppe/src/evaluation.py

@@ -40,7 +40,7 @@ g = torch.from_numpy(gaussian(4 * 1 + 1)).clone()
 g = torch.unsqueeze(g, 1)
 g = g.repeat(17, 1, 1, 1)
 gaussian_kernel.weight.data = g.float()
-gaussian_kernel.cuda()
+gaussian_kernel
 
 
 def prediction(model):
@@ -54,7 +54,7 @@ def prediction(model):
 
     tmp_inp = {}
     for i, (inp, box, im_name, metaData) in enumerate(minival_loader_desc):
-        #inp = torch.autograd.Variable(inp.cuda(), volatile=True)
+        #inp = torch.autograd.Variable(inp, volatile=True)
         pt1, pt2, ori_inp = metaData
         #with torch.autograd.profiler.profile(use_cuda=True) as prof:
         if im_name[0] in tmp_inp.keys():

joints_detectors/Alphapose/train_sppe/src/train.py

@@ -25,9 +25,9 @@ def train(train_loader, m, criterion, optimizer, writer):
     train_loader_desc = tqdm(train_loader)
 
     for i, (inps, labels, setMask, imgset) in enumerate(train_loader_desc):
-        inps = inps.cuda().requires_grad_()
-        labels = labels.cuda()
-        setMask = setMask.cuda()
+        inps = inps.requires_grad_()
+        labels = labels
+        setMask = setMask
         out = m(inps)
 
         loss = criterion(out.mul(setMask), labels)
@@ -68,9 +68,9 @@ def valid(val_loader, m, criterion, optimizer, writer):
     val_loader_desc = tqdm(val_loader)
 
     for i, (inps, labels, setMask, imgset) in enumerate(val_loader_desc):
-        inps = inps.cuda()
-        labels = labels.cuda()
-        setMask = setMask.cuda()
+        inps = inps
+        labels = labels
+        setMask = setMask
 
         with torch.no_grad():
             out = m(inps)
@@ -109,7 +109,7 @@ def valid(val_loader, m, criterion, optimizer, writer):
 def main():
 
     # Model Initialize
-    m = createModel().cuda()
+    m = createModel()
     if opt.loadModel:
         print('Loading Model from {}'.format(opt.loadModel))
         m.load_state_dict(torch.load(opt.loadModel))
@@ -128,7 +128,7 @@ def main():
                 os.mkdir("../exp/{}".format(opt.dataset))
                 os.mkdir("../exp/{}/{}".format(opt.dataset, opt.expID))
 
-    criterion = torch.nn.MSELoss().cuda()
+    criterion = torch.nn.MSELoss()
 
     if opt.optMethod == 'rmsprop':
         optimizer = torch.optim.RMSprop(m.parameters(),
@@ -158,7 +158,7 @@ def main():
         val_dataset, batch_size=opt.validBatch, shuffle=False, num_workers=opt.nThreads, pin_memory=True)
 
     # Model Transfer
-    m = torch.nn.DataParallel(m).cuda()
+    m = torch.nn.DataParallel(m)
 
     # Start Training
     for i in range(opt.nEpochs):

joints_detectors/Alphapose/train_sppe/src/utils/img.py

@@ -208,7 +208,7 @@ def flip(x):
                     np.fliplr(np.transpose(x[i], (0, 2, 1))), (0, 2, 1))
         x = torch.from_numpy(x.copy())
         if is_cuda:
-            x = x.cuda()
+            x = x
     return x
 
 

joints_detectors/Alphapose/video_demo.py

@@ -38,7 +38,7 @@ def main(args):
         pose_model = InferenNet_fast(4 * 1 + 1, pose_dataset)
     else:
         pose_model = InferenNet(4 * 1 + 1, pose_dataset)
-    pose_model.cuda()
+    pose_model
     pose_model.eval()
 
     runtime_profile = {
@@ -73,7 +73,7 @@ def main(args):
             num_batches = datalen // batchSize + leftover
             hm = []
             for j in range(num_batches):
-                inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)].cuda()
+                inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)]
                 hm_j = pose_model(inps_j)
                 hm.append(hm_j)
             hm = torch.cat(hm)

joints_detectors/Alphapose/webcam_demo.py

@@ -45,7 +45,7 @@ if __name__ == "__main__":
         pose_model = InferenNet_fast(4 * 1 + 1, pose_dataset)
     else:
         pose_model = InferenNet(4 * 1 + 1, pose_dataset)
-    pose_model.cuda()
+    pose_model
     pose_model.eval()
 
     # Data writer
@@ -82,7 +82,7 @@ if __name__ == "__main__":
                 num_batches = datalen // batchSize + leftover
                 hm = []
                 for j in range(num_batches):
-                    inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)].cuda()
+                    inps_j = inps[j * batchSize:min((j + 1) * batchSize, datalen)]
                     hm_j = pose_model(inps_j)
                     hm.append(hm_j)
                 hm = torch.cat(hm)

joints_detectors/Alphapose/yolo/bbox.py

@@ -66,7 +66,7 @@ def bbox_iou(box1, box2):
     
     #Intersection area
     
-    inter_area = torch.max(inter_rect_x2 - inter_rect_x1 + 1,torch.zeros(inter_rect_x2.shape).cuda())*torch.max(inter_rect_y2 - inter_rect_y1 + 1, torch.zeros(inter_rect_x2.shape).cuda())
+    inter_area = torch.max(inter_rect_x2 - inter_rect_x1 + 1,torch.zeros(inter_rect_x2.shape))*torch.max(inter_rect_y2 - inter_rect_y1 + 1, torch.zeros(inter_rect_x2.shape))
     
     #Union Area
     b1_area = (b1_x2 - b1_x1 + 1)*(b1_y2 - b1_y1 + 1)

joints_detectors/Alphapose/yolo/cam_demo.py

@@ -22,7 +22,7 @@ def get_test_input(input_dim, CUDA):
     img_ = Variable(img_)
     
     if CUDA:
-        img_ = img_.cuda()
+        img_ = img_
     
     return img_
 
@@ -97,7 +97,7 @@ if __name__ == '__main__':
     assert inp_dim > 32
 
     if CUDA:
-        model.cuda()
+        model
             
     model.eval()
     
@@ -120,8 +120,8 @@ if __name__ == '__main__':
             
             
             if CUDA:
-                im_dim = im_dim.cuda()
-                img = img.cuda()
+                im_dim = im_dim
+                img = img
             
             
             output = model(Variable(img), CUDA)

joints_detectors/Alphapose/yolo/detect.py

@@ -43,7 +43,7 @@ if __name__ == '__main__':
 
     #If there's a GPU availible, put the model on GPU
     if CUDA:
-        model.cuda()
+        model
 
     #Set the model in evaluation mode
     model.eval()
@@ -63,13 +63,13 @@ if __name__ == '__main__':
     im_dim_list = torch.FloatTensor(im_dim_list).repeat(1, 2)
 
     if CUDA:
-        im_dim_list = im_dim_list.cuda()
+        im_dim_list = im_dim_list
 
 
     for batch in im_batches:
         #load the image
         if CUDA:
-            batch = batch.cuda()
+            batch = batch
         with torch.no_grad():
             prediction = model(Variable(batch), CUDA)
 

joints_detectors/Alphapose/yolo/util.py

@@ -57,8 +57,8 @@ def predict_transform(prediction, inp_dim, anchors, num_classes, CUDA = True):
     y_offset = torch.FloatTensor(b).view(-1,1)
     
     if CUDA:
-        x_offset = x_offset.cuda()
-        y_offset = y_offset.cuda()
+        x_offset = x_offset
+        y_offset = y_offset
     
     x_y_offset = torch.cat((x_offset, y_offset), 1).repeat(1,num_anchors).view(-1,2).unsqueeze(0)
     
@@ -68,7 +68,7 @@ def predict_transform(prediction, inp_dim, anchors, num_classes, CUDA = True):
     anchors = torch.FloatTensor(anchors)
     
     if CUDA:
-        anchors = anchors.cuda()
+        anchors = anchors
     
     anchors = anchors.repeat(grid_size*grid_size, 1).unsqueeze(0)
     prediction[:,:,2:4] = torch.exp(prediction[:,:,2:4])*anchors
@@ -251,8 +251,8 @@ def predict_transform_half(prediction, inp_dim, anchors, num_classes, CUDA = Tru
     y_offset = torch.FloatTensor(b).view(-1,1)
     
     if CUDA:
-        x_offset = x_offset.cuda().half()
-        y_offset = y_offset.cuda().half()
+        x_offset = x_offset.half()
+        y_offset = y_offset.half()
     
     x_y_offset = torch.cat((x_offset, y_offset), 1).repeat(1,num_anchors).view(-1,2).unsqueeze(0)
     
@@ -262,7 +262,7 @@ def predict_transform_half(prediction, inp_dim, anchors, num_classes, CUDA = Tru
     anchors = torch.HalfTensor(anchors)
     
     if CUDA:
-        anchors = anchors.cuda()
+        anchors = anchors
     
     anchors = anchors.repeat(grid_size*grid_size, 1).unsqueeze(0)
     prediction[:,:,2:4] = torch.exp(prediction[:,:,2:4])*anchors

joints_detectors/Alphapose/yolo/video_demo.py

@@ -23,7 +23,7 @@ def get_test_input(input_dim, CUDA):
     img_ = Variable(img_)
     
     if CUDA:
-        img_ = img_.cuda()
+        img_ = img_
     
     return img_
 
@@ -106,7 +106,7 @@ if __name__ == '__main__':
     assert inp_dim > 32
 
     if CUDA:
-        model.cuda()
+        model
         
     model(get_test_input(inp_dim, CUDA), CUDA)
 
@@ -132,8 +132,8 @@ if __name__ == '__main__':
             
             
             if CUDA:
-                im_dim = im_dim.cuda()
-                img = img.cuda()
+                im_dim = im_dim
+                img = img
             
             with torch.no_grad():   
                 output = model(Variable(img), CUDA)

joints_detectors/Alphapose/yolo/video_demo_half.py

@@ -23,7 +23,7 @@ def get_test_input(input_dim, CUDA):
     img_ = Variable(img_)
     
     if CUDA:
-        img_ = img_.cuda()
+        img_ = img_
     
     return img_
 
@@ -107,7 +107,7 @@ if __name__ == '__main__':
 
     
     if CUDA:
-        model.cuda().half()
+        model.half()
         
     model(get_test_input(inp_dim, CUDA), CUDA)
 
@@ -133,8 +133,8 @@ if __name__ == '__main__':
             
             
             if CUDA:
-                img = img.cuda().half()
-                im_dim = im_dim.half().cuda()
+                img = img.half()
+                im_dim = im_dim.half()
                 write_results = write_results_half
                 predict_transform = predict_transform_half
             

model/block/refine.py

@@ -27,7 +27,7 @@ class refine(nn.Module):
         x_in = x_in.view(N, -1) 
 
         score = self.post_refine(x_in).view(N,T,V,2) 
-        score_cm = Variable(torch.ones(score.size()), requires_grad=False).cuda() - score
+        score_cm = Variable(torch.ones(score.size()), requires_grad=False) - score
         x_out = x.clone()
         x_out[:, :, :, :2] = score * x[:, :, :, :2] + score_cm * x_1[:, :, :, :2]
 

tools/utils.py

@@ -140,7 +140,7 @@ def videopose_model_load():
     chk_filename = main_path + '/checkpoint/pretrained_h36m_detectron_coco.bin'
     checkpoint = torch.load(chk_filename, map_location=lambda storage, loc: storage)  # 把loc映射到storage
     model_pos = TemporalModel(17, 2, 17, filter_widths=[3, 3, 3, 3, 3], causal=False, dropout=False, channels=1024, dense=False)
-    model_pos = model_pos.cuda()
+    model_pos = model_pos
     model_pos.load_state_dict(checkpoint['model_pos'])
     receptive_field = model_pos.receptive_field()
     return model_pos

videopose_PSTMO.py

@@ -85,11 +85,11 @@ def main(args):
     #                           dense=args.dense)
 
     model = {}
-    model['trans'] = Model(args).cuda()
+    model['trans'] = Model(args)
 
 
     # if torch.cuda.is_available():
-    #     model_pos = model_pos.cuda()
+    #     model_pos = model_pos
 
     ckpt, time1 = ckpt_time(time0)
     print('-------------- load data spends {:.2f} seconds'.format(ckpt))