Fix text and image mismatch (pytorch#1630)

Signed-off-by: Behrooz <[email protected]> 
Thank you @drbeh!

Author: bhashemian

intermediate_source/memory_format_tutorial.py

@@ -9,7 +9,7 @@
 
 Channels last memory format is an alternative way of ordering NCHW tensors in memory preserving dimensions ordering. Channels last tensors ordered in such a way that channels become the densest dimension (aka storing images pixel-per-pixel).
 
-For example, classic (contiguous) storage of NCHW tensor (in our case it is two 2x2 images with 3 color channels) look like this:
+For example, classic (contiguous) storage of NCHW tensor (in our case it is two 4x4 images with 3 color channels) look like this:
 
 .. figure:: /_static/img/classic_memory_format.png
    :alt: classic_memory_format
@@ -37,29 +37,30 @@
 ######################################################################
 # Classic PyTorch contiguous tensor
 import torch
+
 N, C, H, W = 10, 3, 32, 32
 x = torch.empty(N, C, H, W)
-print(x.stride()) # Ouputs: (3072, 1024, 32, 1)
+print(x.stride())  # Ouputs: (3072, 1024, 32, 1)
 
 ######################################################################
 # Conversion operator
 x = x.to(memory_format=torch.channels_last)
-print(x.shape) # Outputs: (10, 3, 32, 32) as dimensions order preserved
-print(x.stride()) # Outputs: (3072, 1, 96, 3)
+print(x.shape)  # Outputs: (10, 3, 32, 32) as dimensions order preserved
+print(x.stride())  # Outputs: (3072, 1, 96, 3)
 
 ######################################################################
 # Back to contiguous
 x = x.to(memory_format=torch.contiguous_format)
-print(x.stride()) # Outputs: (3072, 1024, 32, 1)
+print(x.stride())  # Outputs: (3072, 1024, 32, 1)
 
 ######################################################################
 # Alternative option
 x = x.contiguous(memory_format=torch.channels_last)
-print(x.stride()) # Ouputs: (3072, 1, 96, 3)
+print(x.stride())  # Ouputs: (3072, 1, 96, 3)
 
 ######################################################################
 # Format checks
-print(x.is_contiguous(memory_format=torch.channels_last)) # Ouputs: True
+print(x.is_contiguous(memory_format=torch.channels_last))  # Ouputs: True
 
 ######################################################################
 # There are minor difference between the two APIs ``to`` and
@@ -81,8 +82,8 @@
 # sizes are 1 in order to properly represent the intended memory
 # format
 special_x = torch.empty(4, 1, 4, 4)
-print(special_x.is_contiguous(memory_format=torch.channels_last)) # Ouputs: True
-print(special_x.is_contiguous(memory_format=torch.contiguous_format)) # Ouputs: True
+print(special_x.is_contiguous(memory_format=torch.channels_last))  # Ouputs: True
+print(special_x.is_contiguous(memory_format=torch.contiguous_format))  # Ouputs: True
 
 ######################################################################
 # Same thing applies to explicit permutation API ``permute``. In
@@ -99,28 +100,28 @@
 ######################################################################
 # Create as channels last
 x = torch.empty(N, C, H, W, memory_format=torch.channels_last)
-print(x.stride()) # Ouputs: (3072, 1, 96, 3)
+print(x.stride())  # Ouputs: (3072, 1, 96, 3)
 
 ######################################################################
 # ``clone`` preserves memory format
 y = x.clone()
-print(y.stride()) # Ouputs: (3072, 1, 96, 3)
+print(y.stride())  # Ouputs: (3072, 1, 96, 3)
 
 ######################################################################
 # ``to``, ``cuda``, ``float`` ... preserves memory format
 if torch.cuda.is_available():
     y = x.cuda()
-    print(y.stride()) # Ouputs: (3072, 1, 96, 3)
+    print(y.stride())  # Ouputs: (3072, 1, 96, 3)
 
 ######################################################################
 # ``empty_like``, ``*_like`` operators preserves memory format
 y = torch.empty_like(x)
-print(y.stride()) # Ouputs: (3072, 1, 96, 3)
+print(y.stride())  # Ouputs: (3072, 1, 96, 3)
 
 ######################################################################
 # Pointwise operators preserves memory format
 z = x + y
-print(z.stride()) # Ouputs: (3072, 1, 96, 3)
+print(z.stride())  # Ouputs: (3072, 1, 96, 3)
 
 ######################################################################
 # Conv, Batchnorm modules using cudnn backends support channels last
@@ -132,13 +133,13 @@
 
 if torch.backends.cudnn.version() >= 7603:
     model = torch.nn.Conv2d(8, 4, 3).cuda().half()
-    model = model.to(memory_format=torch.channels_last) # Module parameters need to be channels last
+    model = model.to(memory_format=torch.channels_last)  # Module parameters need to be channels last
 
     input = torch.randint(1, 10, (2, 8, 4, 4), dtype=torch.float32, requires_grad=True)
     input = input.to(device="cuda", memory_format=torch.channels_last, dtype=torch.float16)
 
     out = model(input)
-    print(out.is_contiguous(memory_format=torch.channels_last)) # Ouputs: True
+    print(out.is_contiguous(memory_format=torch.channels_last))  # Ouputs: True
 
 ######################################################################
 # When input tensor reaches a operator without channels last support,
@@ -195,7 +196,7 @@
 
 ######################################################################
 # Passing ``--channels-last true`` allows running a model in Channels last format with observed 22% perf gain.
-# 
+#
 # ``python main_amp.py -a resnet50 --b 200 --workers 16 --opt-level O2 --channels-last true ./data``
 
 # opt_level = O2
@@ -250,10 +251,10 @@
 #
 
 # Need to be done once, after model initialization (or load)
-model = model.to(memory_format=torch.channels_last) # Replace with your model
+model = model.to(memory_format=torch.channels_last)  # Replace with your model
 
 # Need to be done for every input
-input = input.to(memory_format=torch.channels_last) # Replace with your input
+input = input.to(memory_format=torch.channels_last)  # Replace with your input
 output = model(input)
 
 #######################################################################
@@ -271,8 +272,8 @@
 # operatos in your model that does not support channels last, if you
 # want to improve the performance of converted model.
 #
-# That means you need to verify the list of used operators 
-# against supported operators list https://github.com/pytorch/pytorch/wiki/Operators-with-Channels-Last-support, 
+# That means you need to verify the list of used operators
+# against supported operators list https://github.com/pytorch/pytorch/wiki/Operators-with-Channels-Last-support,
 # or introduce memory format checks into eager execution mode and run your model.
 #
 # After running the code below, operators will raise an exception if the output of the
@@ -290,13 +291,13 @@ def contains_cl(args):
     return False
 
 
-def print_inputs(args, indent=''):
+def print_inputs(args, indent=""):
     for t in args:
         if isinstance(t, torch.Tensor):
             print(indent, t.stride(), t.shape, t.device, t.dtype)
         elif isinstance(t, list) or isinstance(t, tuple):
             print(indent, type(t))
-            print_inputs(list(t), indent=indent + '    ')
+            print_inputs(list(t), indent=indent + "    ")
         else:
             print(indent, t)
 
@@ -311,32 +312,38 @@ def check_cl(*args, **kwargs):
         except Exception as e:
             print("`{}` inputs are:".format(name))
             print_inputs(args)
-            print('-------------------')
+            print("-------------------")
             raise e
         failed = False
         if was_cl:
             if isinstance(result, torch.Tensor):
                 if result.dim() == 4 and not result.is_contiguous(memory_format=torch.channels_last):
-                    print("`{}` got channels_last input, but output is not channels_last:".format(name),
-                          result.shape, result.stride(), result.device, result.dtype)
+                    print(
+                        "`{}` got channels_last input, but output is not channels_last:".format(name),
+                        result.shape,
+                        result.stride(),
+                        result.device,
+                        result.dtype,
+                    )
                     failed = True
         if failed and True:
             print("`{}` inputs are:".format(name))
             print_inputs(args)
-            raise Exception(
-                'Operator `{}` lost channels_last property'.format(name))
+            raise Exception("Operator `{}` lost channels_last property".format(name))
         return result
+
     return check_cl
 
+
 old_attrs = dict()
 
+
 def attribute(m):
     old_attrs[m] = dict()
     for i in dir(m):
         e = getattr(m, i)
-        exclude_functions = ['is_cuda', 'has_names', 'numel',
-                             'stride', 'Tensor', 'is_contiguous', '__class__']
-        if i not in exclude_functions and not i.startswith('_') and '__call__' in dir(e):
+        exclude_functions = ["is_cuda", "has_names", "numel", "stride", "Tensor", "is_contiguous", "__class__"]
+        if i not in exclude_functions and not i.startswith("_") and "__call__" in dir(e):
             try:
                 old_attrs[m][i] = e
                 setattr(m, i, check_wrapper(e))
@@ -352,16 +359,16 @@ def attribute(m):
 
 ######################################################################
 # If you found an operator that doesn't support channels last tensors
-# and you want to contribute, feel free to use following developers 
+# and you want to contribute, feel free to use following developers
 # guide https://github.com/pytorch/pytorch/wiki/Writing-memory-format-aware-operators.
 #
 
 ######################################################################
 # Code below is to recover the attributes of torch.
 
 for (m, attrs) in old_attrs.items():
-  for (k,v) in attrs.items():
-    setattr(m, k, v)
+    for (k, v) in attrs.items():
+        setattr(m, k, v)
 
 ######################################################################
 # Work to do