Quiero hacer algunas comparaciones de tiempo entre CPU y GPU, así como algunos perfiles y me gustaría saber si hay una manera de decirle a pytorch que no use la GPU y en su lugar use solo la CPU. Me doy cuenta de que podría instalar otro pytorch solo para CPU, pero espero que haya una manera más fácil.

Antes de ejecutar su código, ejecute este comando de shell para decirle a torch que no hay GPU:

export CUDA_VISIBLE_DEVICES=""

Esto le indicará que use solo una GPU (la que tiene id 0) y así sucesivamente:

export CUDA_VISIBLE_DEVICES="0"

Solo quería agregar que también es posible hacerlo dentro del Código PyTorch:

Aquí hay un pequeño ejemplo tomado de la Guía de migración de PyTorch para 0.4.0:

# at beginning of the script
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

...

# then whenever you get a new Tensor or Module
# this won't copy if they are already on the desired device
input = data.to(device)
model = MyModule(...).to(device)

Creo que el ejemplo es bastante autoexplicativo. Pero si hay alguna pregunta, ¡solo pregunte!
Una gran ventaja es que cuando se usa esta sintaxis como en el ejemplo anterior, puede crear código que se ejecuta en la CPU si no hay una GPU disponible, pero también en la GPU sin cambiar una sola línea.

En lugar de usar el sentencia if con torch.cuda.is_available() también puede simplemente configurar el dispositivo para UPC como esto:

device = torch.device("cpu")

Además, puede crear tensores en el deseado dispositivo utilizando el device bandera:

mytensor = torch.rand(5, 5, device=device)

Esto creará un tensor directamente en el device usted especificó anteriormente.

Quiero señalar que puedes cambiar entre UPC y GPU usando esta sintaxis, sino también entre diferentes GPU.

¡Espero que esto sea útil!

La forma más sencilla de usar Python es:

os.environ["CUDA_VISIBLE_DEVICES"]=""

Hay varias formas de forzar el uso de la CPU:

1. Establecer el tipo de tensor predeterminado:

   torch.set_default_tensor_type(torch.FloatTensor)
   

2. Establezca el dispositivo y haga referencia consistentemente al crear tensores:

   (con esto puedes cambiar fácilmente entre GPU y CPU)

   device="cpu"
   # ...
   x = torch.rand(2, 10, device=device)
   

3. Ocultar GPU de la vista:

   import os
   
   os.environ["CUDA_VISIBLE_DEVICES"]=""
   

General

Como mostraron las respuestas anteriores, puede hacer que su pytorch se ejecute en la CPU usando:

device = torch.device("cpu")

Comparación de modelos entrenados

Me gustaría agregar cómo puede cargar un modelo previamente entrenado en la cpu (ejemplos tomados de la documentos de pytorch).

Nota: asegúrese de que todos los datos ingresados ​​en el modelo también estén en la CPU.

Carga recomendada

model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH, map_location=torch.device("cpu")))

Cargando todo el modelo

model = torch.load(PATH, map_location=torch.device("cpu"))

Este es un ejemplo del mundo real: función original con gpu, versus función nueva con cpu.

Fuente: https://github.com/zllrunning/face-parsing.PyTorch/blob/master/test.py

En mi caso he editado estas 4 líneas de código:

#totally new line of code
device=torch.device("cpu")



#net.cuda()
net.to(device)

#net.load_state_dict(torch.load(cp))
net.load_state_dict(torch.load(cp, map_location=torch.device('cpu')))

#img = img.cuda()
img = img.to(device)

#new_function_with_cpu
def evaluate(image_path="./imgs/116.jpg", cp='cp/79999_iter.pth'):
    device=torch.device("cpu")
    n_classes = 19
    net = BiSeNet(n_classes=n_classes)
    #net.cuda()
    net.to(device)
    #net.load_state_dict(torch.load(cp))
    net.load_state_dict(torch.load(cp, map_location=torch.device('cpu')))
    net.eval()

    to_tensor = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),])

    with torch.no_grad():
        img = Image.open(image_path)
        image = img.resize((512, 512), Image.BILINEAR)
        img = to_tensor(image)
        img = torch.unsqueeze(img, 0)
        #img = img.cuda()
        img = img.to(device)
        out = net(img)[0]
        parsing = out.squeeze(0).cpu().numpy().argmax(0)
        return parsing


















#original_function_with_gpu


def evaluate(image_path="./imgs/116.jpg", cp='cp/79999_iter.pth'):

    n_classes = 19
    net = BiSeNet(n_classes=n_classes)
    net.cuda()
    net.load_state_dict(torch.load(cp))
    net.eval()

    to_tensor = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),])

    with torch.no_grad():
        img = Image.open(image_path)
        image = img.resize((512, 512), Image.BILINEAR)
        img = to_tensor(image)
        img = torch.unsqueeze(img, 0)
        img = img.cuda()
        out = net(img)[0]
        parsing = out.squeeze(0).cpu().numpy().argmax(0)
        return parsing