Automated tutorials push

Author: pytorchbot

_downloads/19879e6777280194639314bd79851483/knowledge_distillation_tutorial.py

@@ -37,8 +37,10 @@
 import torchvision.transforms as transforms
 import torchvision.datasets as datasets
 
-# Check if GPU is available, and if not, use the CPU
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# Check if the current `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# is available, and if not, use the CPU
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
 
 ######################################################################
 # Loading CIFAR-10

_downloads/44a84f8c1764dbf61662d306ff9ed43a/chatbot_tutorial.ipynb

@@ -136,8 +136,10 @@
     "import json\n",
     "\n",
     "\n",
-    "USE_CUDA = torch.cuda.is_available()\n",
-    "device = torch.device(\"cuda\" if USE_CUDA else \"cpu\")"
+    "# If the current `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__ is available,\n",
+    "# we will use it. Otherwise, we use the CPU.\n",
+    "device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else \"cpu\"\n",
+    "print(f\"Using {device} device\")"
    ]
   },
   {
@@ -1531,16 +1533,16 @@
     "    encoder_optimizer.load_state_dict(encoder_optimizer_sd)\n",
     "    decoder_optimizer.load_state_dict(decoder_optimizer_sd)\n",
     "\n",
-    "# If you have CUDA, configure CUDA to call\n",
+    "# If you have an accelerator, configure it to call\n",
     "for state in encoder_optimizer.state.values():\n",
     "    for k, v in state.items():\n",
     "        if isinstance(v, torch.Tensor):\n",
-    "            state[k] = v.cuda()\n",
+    "            state[k] = v.to(device)\n",
     "\n",
     "for state in decoder_optimizer.state.values():\n",
     "    for k, v in state.items():\n",
     "        if isinstance(v, torch.Tensor):\n",
-    "            state[k] = v.cuda()\n",
+    "            state[k] = v.to(device)\n",
     "\n",
     "# Run training iterations\n",
     "print(\"Starting Training!\")\n",

_downloads/63a0f0fc7b3ffb15d3a5ac8db3d521ee/tensors_deeper_tutorial.ipynb

@@ -857,23 +857,23 @@
     "does this *without* changing `a` - you can see that when we print `a`\n",
     "again at the end, it retains its `requires_grad=True` property.\n",
     "\n",
-    "Moving to GPU\n",
-    "=============\n",
+    "Moving to\n",
+    "[Accelerator](https://pytorch.org/docs/stable/torch.html#accelerators)\n",
+    "\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\--\n",
     "\n",
-    "One of the major advantages of PyTorch is its robust acceleration on\n",
-    "CUDA-compatible Nvidia GPUs. (\"CUDA\" stands for *Compute Unified Device\n",
-    "Architecture*, which is Nvidia's platform for parallel computing.) So\n",
-    "far, everything we've done has been on CPU. How do we move to the faster\n",
-    "hardware?\n",
+    "One of the major advantages of PyTorch is its robust acceleration on an\n",
+    "[accelerator](https://pytorch.org/docs/stable/torch.html#accelerators)\n",
+    "such as CUDA, MPS, MTIA, or XPU. So far, everything we've done has been\n",
+    "on CPU. How do we move to the faster hardware?\n",
     "\n",
-    "First, we should check whether a GPU is available, with the\n",
+    "First, we should check whether an accelerator is available, with the\n",
     "`is_available()` method.\n",
     "\n",
     "<div style=\"background-color: #54c7ec; color: #fff; font-weight: 700; padding-left: 10px; padding-top: 5px; padding-bottom: 5px\"><strong>NOTE:</strong></div>\n",
     "\n",
     "<div style=\"background-color: #f3f4f7; padding-left: 10px; padding-top: 10px; padding-bottom: 10px; padding-right: 10px\">\n",
     "\n",
-    "<p>If you do not have a CUDA-compatible GPU and CUDA driversinstalled, the executable cells in this section will not execute anyGPU-related code.</p>\n",
+    "<p>If you do not have an accelerator, the executable cells in this section will not execute anyaccelerator-related code.</p>\n",
     "\n",
     "</div>\n",
     "\n"
@@ -887,8 +887,8 @@
    },
    "outputs": [],
    "source": [
-    "if torch.cuda.is_available():\n",
-    "    print('We have a GPU!')\n",
+    "if torch.accelerator.is_available():\n",
+    "    print('We have an accelerator!')\n",
     "else:\n",
     "    print('Sorry, CPU only.')"
    ]
@@ -897,13 +897,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Once we've determined that one or more GPUs is available, we need to put\n",
-    "our data someplace where the GPU can see it. Your CPU does computation\n",
-    "on data in your computer's RAM. Your GPU has dedicated memory attached\n",
-    "to it. Whenever you want to perform a computation on a device, you must\n",
-    "move *all* the data needed for that computation to memory accessible by\n",
-    "that device. (Colloquially, \"moving the data to memory accessible by the\n",
-    "GPU\" is shorted to, \"moving the data to the GPU\".)\n",
+    "Once we've determined that one or more accelerators is available, we\n",
+    "need to put our data someplace where the accelerator can see it. Your\n",
+    "CPU does computation on data in your computer's RAM. Your accelerator\n",
+    "has dedicated memory attached to it. Whenever you want to perform a\n",
+    "computation on a device, you must move *all* the data needed for that\n",
+    "computation to memory accessible by that device. (Colloquially, \"moving\n",
+    "the data to memory accessible by the GPU\" is shorted to, \"moving the\n",
+    "data to the GPU\".)\n",
     "\n",
     "There are multiple ways to get your data onto your target device. You\n",
     "may do it at creation time:\n"
@@ -917,8 +918,8 @@
    },
    "outputs": [],
    "source": [
-    "if torch.cuda.is_available():\n",
-    "    gpu_rand = torch.rand(2, 2, device='cuda')\n",
+    "if torch.accelerator.is_available():\n",
+    "    gpu_rand = torch.rand(2, 2, device=torch.accelerator.current_accelerator())\n",
     "    print(gpu_rand)\n",
     "else:\n",
     "    print('Sorry, CPU only.')"
@@ -929,19 +930,20 @@
    "metadata": {},
    "source": [
     "By default, new tensors are created on the CPU, so we have to specify\n",
-    "when we want to create our tensor on the GPU with the optional `device`\n",
-    "argument. You can see when we print the new tensor, PyTorch informs us\n",
-    "which device it's on (if it's not on CPU).\n",
+    "when we want to create our tensor on the accelerator with the optional\n",
+    "`device` argument. You can see when we print the new tensor, PyTorch\n",
+    "informs us which device it's on (if it's not on CPU).\n",
     "\n",
-    "You can query the number of GPUs with `torch.cuda.device_count()`. If\n",
-    "you have more than one GPU, you can specify them by index:\n",
+    "You can query the number of accelerators with\n",
+    "`torch.accelerator.device_count()`. If you have more than one\n",
+    "accelerator, you can specify them by index, take CUDA for example:\n",
     "`device='cuda:0'`, `device='cuda:1'`, etc.\n",
     "\n",
     "As a coding practice, specifying our devices everywhere with string\n",
     "constants is pretty fragile. In an ideal world, your code would perform\n",
-    "robustly whether you're on CPU or GPU hardware. You can do this by\n",
-    "creating a device handle that can be passed to your tensors instead of a\n",
-    "string:\n"
+    "robustly whether you're on CPU or accelerator hardware. You can do this\n",
+    "by creating a device handle that can be passed to your tensors instead\n",
+    "of a string:\n"
    ]
   },
   {
@@ -952,10 +954,7 @@
    },
    "outputs": [],
    "source": [
-    "if torch.cuda.is_available():\n",
-    "    my_device = torch.device('cuda')\n",
-    "else:\n",
-    "    my_device = torch.device('cpu')\n",
+    "my_device = torch.accelerator.current_accelerator() if torch.accelerator.is_available() else torch.device('cpu')\n",
     "print('Device: {}'.format(my_device))\n",
     "\n",
     "x = torch.rand(2, 2, device=my_device)\n",
@@ -991,11 +990,11 @@
     "It is important to know that in order to do computation involving two or\n",
     "more tensors, *all of the tensors must be on the same device*. The\n",
     "following code will throw a runtime error, regardless of whether you\n",
-    "have a GPU device available:\n",
+    "have an accelerator device available, take CUDA for example:\n",
     "\n",
     "``` {.python}\n",
     "x = torch.rand(2, 2)\n",
-    "y = torch.rand(2, 2, device='gpu')\n",
+    "y = torch.rand(2, 2, device='cuda')\n",
     "z = x + y  # exception will be thrown\n",
     "```\n"
    ]

_downloads/a19d8941b0ebb13c102e41c7e24bc5fb/knowledge_distillation_tutorial.ipynb

@@ -73,8 +73,10 @@
     "import torchvision.transforms as transforms\n",
     "import torchvision.datasets as datasets\n",
     "\n",
-    "# Check if GPU is available, and if not, use the CPU\n",
-    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
+    "# Check if the current `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__\n",
+    "# is available, and if not, use the CPU\n",
+    "device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else \"cpu\"\n",
+    "print(f\"Using {device} device\")"
    ]
   },
   {

_downloads/be017e7b39198fdf668c138fd8d57abe/tensors_deeper_tutorial.py

@@ -632,34 +632,33 @@
 # does this *without* changing ``a`` - you can see that when we print
 # ``a`` again at the end, it retains its ``requires_grad=True`` property.
 # 
-# Moving to GPU
+# Moving to `Accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
 # -------------
 # 
-# One of the major advantages of PyTorch is its robust acceleration on
-# CUDA-compatible Nvidia GPUs. (“CUDA” stands for *Compute Unified Device
-# Architecture*, which is Nvidia’s platform for parallel computing.) So
-# far, everything we’ve done has been on CPU. How do we move to the faster
+# One of the major advantages of PyTorch is its robust acceleration on an
+# `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__
+# such as CUDA, MPS, MTIA, or XPU. 
+# So far, everything we’ve done has been on CPU. How do we move to the faster
 # hardware?
 # 
-# First, we should check whether a GPU is available, with the
+# First, we should check whether an accelerator is available, with the
 # ``is_available()`` method.
 # 
 # .. note::
-#      If you do not have a CUDA-compatible GPU and CUDA drivers
-#      installed, the executable cells in this section will not execute any
-#      GPU-related code.
+#      If you do not have an accelerator, the executable cells in this section will not execute any
+#      accelerator-related code.
 # 
 
-if torch.cuda.is_available():
-    print('We have a GPU!')
+if torch.accelerator.is_available():
+    print('We have an accelerator!')
 else:
     print('Sorry, CPU only.')
 
 
 ##########################################################################
-# Once we’ve determined that one or more GPUs is available, we need to put
-# our data someplace where the GPU can see it. Your CPU does computation
-# on data in your computer’s RAM. Your GPU has dedicated memory attached
+# Once we’ve determined that one or more accelerators is available, we need to put
+# our data someplace where the accelerator can see it. Your CPU does computation
+# on data in your computer’s RAM. Your accelerator has dedicated memory attached
 # to it. Whenever you want to perform a computation on a device, you must
 # move *all* the data needed for that computation to memory accessible by
 # that device. (Colloquially, “moving the data to memory accessible by the
@@ -669,34 +668,31 @@
 # may do it at creation time:
 # 
 
-if torch.cuda.is_available():
-    gpu_rand = torch.rand(2, 2, device='cuda')
+if torch.accelerator.is_available():
+    gpu_rand = torch.rand(2, 2, device=torch.accelerator.current_accelerator())
     print(gpu_rand)
 else:
     print('Sorry, CPU only.')
 
 
 ##########################################################################
 # By default, new tensors are created on the CPU, so we have to specify
-# when we want to create our tensor on the GPU with the optional
+# when we want to create our tensor on the accelerator with the optional
 # ``device`` argument. You can see when we print the new tensor, PyTorch
 # informs us which device it’s on (if it’s not on CPU).
 # 
-# You can query the number of GPUs with ``torch.cuda.device_count()``. If
-# you have more than one GPU, you can specify them by index:
+# You can query the number of accelerators with ``torch.accelerator.device_count()``. If
+# you have more than one accelerator, you can specify them by index, take CUDA for example:
 # ``device='cuda:0'``, ``device='cuda:1'``, etc.
 # 
 # As a coding practice, specifying our devices everywhere with string
 # constants is pretty fragile. In an ideal world, your code would perform
-# robustly whether you’re on CPU or GPU hardware. You can do this by
+# robustly whether you’re on CPU or accelerator hardware. You can do this by
 # creating a device handle that can be passed to your tensors instead of a
 # string:
 # 
 
-if torch.cuda.is_available():
-    my_device = torch.device('cuda')
-else:
-    my_device = torch.device('cpu')
+my_device = torch.accelerator.current_accelerator() if torch.accelerator.is_available() else torch.device('cpu')
 print('Device: {}'.format(my_device))
 
 x = torch.rand(2, 2, device=my_device)
@@ -718,12 +714,12 @@
 # It is important to know that in order to do computation involving two or
 # more tensors, *all of the tensors must be on the same device*. The
 # following code will throw a runtime error, regardless of whether you
-# have a GPU device available:
+# have an accelerator device available, take CUDA for example:
 # 
 # .. code-block:: python
 # 
 #    x = torch.rand(2, 2)
-#    y = torch.rand(2, 2, device='gpu')
+#    y = torch.rand(2, 2, device='cuda')
 #    z = x + y  # exception will be thrown
 # 
 

_downloads/d90127b0deeb355be3a350521d770206/chatbot_tutorial.py

@@ -108,8 +108,10 @@
 import json
 
 
-USE_CUDA = torch.cuda.is_available()
-device = torch.device("cuda" if USE_CUDA else "cpu")
+# If the current `accelerator <https://pytorch.org/docs/stable/torch.html#accelerators>`__ is available,
+# we will use it. Otherwise, we use the CPU.
+device = torch.accelerator.current_accelerator().type if torch.accelerator.is_available() else "cpu"
+print(f"Using {device} device")
 
 
 ######################################################################
@@ -1318,16 +1320,16 @@ def evaluateInput(encoder, decoder, searcher, voc):
     encoder_optimizer.load_state_dict(encoder_optimizer_sd)
     decoder_optimizer.load_state_dict(decoder_optimizer_sd)
 
-# If you have CUDA, configure CUDA to call
+# If you have an accelerator, configure it to call
 for state in encoder_optimizer.state.values():
     for k, v in state.items():
         if isinstance(v, torch.Tensor):
-            state[k] = v.cuda()
+            state[k] = v.to(device)
 
 for state in decoder_optimizer.state.values():
     for k, v in state.items():
         if isinstance(v, torch.Tensor):
-            state[k] = v.cuda()
+            state[k] = v.to(device)
 
 # Run training iterations
 print("Starting Training!")