title: AssertionError: Torch not compiled with CUDA enabled (problem in torch vision)
body: <p>so I am trying to run my object detection program and I keep getting the following error message:</p>
  <p>AssertionError: Torch not compiled with CUDA enabled.</p>
  <p>I don't understand why this happens, as I have a 2017 MacBook Pro with an AMD GPU, so I have no CUDA enabled GPU.</p>
  <p>I added this statement in my code to make sure the device is set to 'cpu', however, it looks as if the program keeps trying to run it through a GPU even though it does not exist.</p>
  <pre><code>if torch.cuda.is_available():
      device = torch.device('cuda')
      
  else:
      device = torch.device('cpu')
  </code></pre>
  <p>This is the place where the error happens (4th line):</p>
  <pre><code>    for epoch in range(num_epochs):
          # train for one epoch, printing every 10 iterations
          print(&quot;Hey&quot;)
          train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)
          print(&quot;Hey&quot;)
          # update the learning rate
          lr_scheduler.step()
          # evaluate on the test dataset
          evaluate(model, data_loader_test, device=device)
  </code></pre>
  <p>It would be really great, if anyone could help me with this issue!</p>
  <p>Thanks everyone in advance!</p>
  <p>PS: I already tried updating the Pytorch version, but still same problem.</p>
  <p>Error output:</p>
  <p><a href="https://i.stack.imgur.com/PoJiE.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/PoJiE.png" alt="Error output" /></a></p>
  <pre><code>import os
  import pandas as pd
  import torch
  import torch.utils.data
  import torchvision
  from PIL import Image
  import utils
  from engine import train_one_epoch, evaluate
  import transforms as T
  from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
  
  
  def parse_one_annot(path_to_data_file, filename):
      data = pd.read_csv(path_to_data_file)
      boxes_array = data[data[&quot;filename&quot;] == filename][[&quot;xmin&quot;, &quot;ymin&quot;, &quot;xmax&quot;, &quot;ymax&quot;]].values
  
      return boxes_array
  
  
  class RaccoonDataset(torch.utils.data.Dataset):
  
      def __init__(self, root, data_file, transforms=None):
          self.root = root
          self.transforms = transforms
          self.imgs = sorted(os.listdir(os.path.join(root, &quot;images&quot;)))
          self.path_to_data_file = data_file
  
      def __getitem__(self, idx):
          # load images and bounding boxes
          img_path = os.path.join(self.root, &quot;images&quot;, self.imgs[idx])
          img = Image.open(img_path).convert(&quot;RGB&quot;)
          box_list = parse_one_annot(self.path_to_data_file,
                                     self.imgs[idx])
          boxes = torch.as_tensor(box_list, dtype=torch.float32)
  
          num_objs = len(box_list)
          # there is only one class
          labels = torch.ones((num_objs,), dtype=torch.int64)
          image_id = torch.tensor([idx])
          area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])
          # suppose all instances are not crowd
          iscrowd = torch.zeros((num_objs,), dtype=torch.int64)
          target = {}
          target[&quot;boxes&quot;] = boxes
          target[&quot;labels&quot;] = labels
          target[&quot;image_id&quot;] = image_id
          target[&quot;area&quot;] = area
          target[&quot;iscrowd&quot;] = iscrowd
  
          if self.transforms is not None:
              img, target = self.transforms(img, target)
              return img, target
  
      def __len__(self):
          return len(self.imgs)
  
  
  dataset = RaccoonDataset(root=&quot;./raccoon_dataset&quot;, data_file=&quot;./raccoon_dataset/data/raccoon_labels.csv&quot;)
  
  dataset.__getitem__(0)
  
  
  def get_model(num_classes):
      model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
  
      in_features = model.roi_heads.box_predictor.cls_score.in_features
      # replace the pre-trained head with a new on
      model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
  
      return model
  
  
  def get_transform(train):
      transforms = []
      # converts the image, a PIL image, into a PyTorch Tensor
      transforms.append(T.ToTensor())
  
      if train:
          # during training, randomly flip the training images
          # and ground-truth for data augmentation
          transforms.append(T.RandomHorizontalFlip(0.5))
      return T.Compose(transforms)
  
  
  def main():
  
      dataset = RaccoonDataset(root=&quot;./raccoon_dataset&quot;,
                               data_file=&quot;raccoon_dataset/data/raccoon_labels.csv&quot;,
                               transforms=get_transform(train=True))
  
      dataset_test = RaccoonDataset(root=&quot;./raccoon_dataset&quot;,
                                    data_file=&quot;raccoon_dataset/data/raccoon_labels.csv&quot;,
                                    transforms=get_transform(train=False))
  
      torch.manual_seed(1)
      indices = torch.randperm(len(dataset)).tolist()
      dataset = torch.utils.data.Subset(dataset, indices[:-40])
      dataset_test = torch.utils.data.Subset(dataset_test, indices[-40:])
  
      # define training and validation data loaders
      data_loader = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True, num_workers=4,
                                                collate_fn=utils.collate_fn)
      data_loader_test = torch.utils.data.DataLoader(dataset_test, batch_size=1, shuffle=False, num_workers=4,
                                                     collate_fn=utils.collate_fn)
  
      print(&quot;We have: {} examples, {} are training and {} testing&quot;.format(len(indices), len(dataset), len(dataset_test)))
  
      if torch.cuda.is_available():
          device = torch.device('cuda')
      else:
          device = torch.device('cpu')
  
      num_classes = 2
      model = get_model(num_classes)
  
      # construct an optimizer
      params = [p for p in model.parameters() if p.requires_grad]
      optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005)
  
      # and a learning rate scheduler which decreases the learning rate by
      # 10x every 3 epochs
  
      lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1)
  
      # let's train it for 10 epochs
  
      num_epochs = 10
  
      for epoch in range(num_epochs):
          # train for one epoch, printing every 10 iterations
          train_one_epoch(model, optimizer, data_loader, device, epoch, print_freq=10)
          # update the learning rate
          lr_scheduler.step()
          # evaluate on the test dataset
          evaluate(model, data_loader_test, device=device)
  
  
      os.mkdir(&quot;pytorch object detection/raccoon/&quot;)
      torch.save(model.state_dict(), &quot;pytorch object detection/raccoon/model&quot;)
  
  
  if __name__ == '__main__':
      main()
  </code></pre>