diff --git a/README.md b/README.md
index 68d6866b5..77c6b6ebf 100644
--- a/README.md
+++ b/README.md
@@ -53,38 +53,38 @@ limitations under the License.
 Here is an example:
 
 ```diff
-import torch
-import torch.nn.functional as F
-from datasets import load_dataset
+  import torch
+  import torch.nn.functional as F
+  from datasets import load_dataset
 
 + from accelerate import Accelerator
 + accelerator = Accelerator()
 - device = 'cpu'
 + device = accelerator.device
 
-model = torch.nn.Transformer().to(device)
-optim = torch.optim.Adam(model.parameters())
+  model = torch.nn.Transformer().to(device)
+  optim = torch.optim.Adam(model.parameters())
 
-dataset = load_dataset('my_dataset')
-data = torch.utils.data.Dataloader(dataset)
+  dataset = load_dataset('my_dataset')
+  data = torch.utils.data.Dataloader(dataset)
 
 + model, optim, data = accelerator.prepare(model, optim, data)
 
-model.train()
-for epoch in range(10):
-    for source, targets in data:
-        source = source.to(device)
-        targets = targets.to(device)
+  model.train()
+  for epoch in range(10):
+      for source, targets in data:
+          source = source.to(device)
+          targets = targets.to(device)
 
-        optimizer.zero_grad()
+          optimizer.zero_grad()
 
-        output = model(source, targets)
-        loss = F.cross_entropy(output, targets)
+          output = model(source, targets)
+          loss = F.cross_entropy(output, targets)
 
 +         accelerator.backward(loss)
 -         loss.backward()
 
-        optimizer.step()
+          optimizer.step()
 ```
 
 As you can see in this example, by adding 5-lines to any standard PyTorch training script you can now run on any kind of single or distributed node setting (single CPU, single GPU, multi-GPUs and TPUs) as well as with or without mixed precision (fp16).
@@ -94,9 +94,9 @@ In particular, the same code can then be run without modification on your local
 🤗 Accelerate even handles the device placement for you (which requires a few more changes to your code, but is safer in general), so you can even simplify your training loop further:
 
 ```diff
-import torch
-import torch.nn.functional as F
-from datasets import load_dataset
+  import torch
+  import torch.nn.functional as F
+  from datasets import load_dataset
 
 + from accelerate import Accelerator
 + accelerator = Accelerator()
@@ -104,28 +104,28 @@ from datasets import load_dataset
 
 + model = torch.nn.Transformer()
 - model = torch.nn.Transformer().to(device)
-optim = torch.optim.Adam(model.parameters())
+  optim = torch.optim.Adam(model.parameters())
 
-dataset = load_dataset('my_dataset')
-data = torch.utils.data.Dataloader(dataset)
+  dataset = load_dataset('my_dataset')
+  data = torch.utils.data.Dataloader(dataset)
 
 + model, optim, data = accelerator.prepare(model, optim, data)
 
-model.train()
-for epoch in range(10):
-    for source, targets in data:
+  model.train()
+  for epoch in range(10):
+      for source, targets in data:
 -         source = source.to(device)
 -         targets = targets.to(device)
 
-        optimizer.zero_grad()
+          optimizer.zero_grad()
 
-        output = model(source, targets)
-        loss = F.cross_entropy(output, targets)
+          output = model(source, targets)
+          loss = F.cross_entropy(output, targets)
 
 +         accelerator.backward(loss)
 -         loss.backward()
 
-        optimizer.step()
+          optimizer.step()
 ```
 
 ## Launching script
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 57933888d..efdeb8f88 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -47,53 +47,58 @@ A traditional training loop in PyTorch looks like this:
 
 Changing it to work with accelerate is really easy and only adds a few lines of code:
 
-.. code-block:: python
-
-    from accelerate import Accelerator
-
-    accelerator = Accelerator()
-    # Use the device given by the `accelerator` object.
-    device = accelerator.device
-    my_model.to(device)
-    # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`
-    my_model, my_optimizer, my_training_dataloader = accelerate.prepare(
-        my_model, my_optimizer, my_training_dataloader
-    )
-
-    for batch in my_training_dataloader:
-        my_optimizer.zero_grad()
-        inputs, targets = batch
-        inputs = inputs.to(device)
-        targets = targets.to(device)
-        outputs = my_model(inputs)
-        loss = my_loss_function(outputs, targets)
-        # Just a small change for the backward instruction
-        accelerate.backward(loss)
-        my_optimizer.step()
+.. code-block:: diff
+
+    + from accelerate import Accelerator
+
+    + accelerator = Accelerator()
+      # Use the device given by the `accelerator` object.
+    + device = accelerator.device
+      my_model.to(device)
+      # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`
+    + my_model, my_optimizer, my_training_dataloader = accelerate.prepare(
+    +     my_model, my_optimizer, my_training_dataloader
+    + )
+
+      for batch in my_training_dataloader:
+          my_optimizer.zero_grad()
+          inputs, targets = batch
+          inputs = inputs.to(device)
+          targets = targets.to(device)
+          outputs = my_model(inputs)
+          loss = my_loss_function(outputs, targets)
+          # Just a small change for the backward instruction
+    -     loss.backward()
+    +     accelerate.backward(loss)
+          my_optimizer.step()
 
 and with this, your script can now run in a distributed environment (multi-GPU, TPU).
 
 You can even simplify your script a bit by letting 🤗 Accelerate handle the device placement for you (which is safer,
 especially for TPU training):
 
-.. code-block:: python
-
-    from accelerate import Accelerator
-
-    accelerator = Accelerator()
-    # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`
-    my_model, my_optimizer, my_training_dataloader = accelerate.prepare(
-        my_model, my_optimizer, my_training_dataloader
-    )
-
-    for batch in my_training_dataloader:
-        my_optimizer.zero_grad()
-        inputs, targets = batch
-        outputs = my_model(inputs)
-        loss = my_loss_function(outputs, targets)
-        # Just a small change for the backward instruction
-        accelerate.backward(loss)
-        my_optimizer.step()
+.. code-block:: diff
+
+    + from accelerate import Accelerator
+
+    + accelerator = Accelerator()
+    - my_model.to(device)
+      # Pass every important object (model, optimizer, dataloader) to `accelerator.prepare`
+    + my_model, my_optimizer, my_training_dataloader = accelerate.prepare(
+    +     my_model, my_optimizer, my_training_dataloader
+    + )
+
+      for batch in my_training_dataloader:
+          my_optimizer.zero_grad()
+          inputs, targets = batch
+    -     inputs = inputs.to(device)
+    -     targets = targets.to(device)
+          outputs = my_model(inputs)
+          loss = my_loss_function(outputs, targets)
+          # Just a small change for the backward instruction
+    -     loss.backward()
+    +     accelerate.backward(loss)
+          my_optimizer.step()
 
 
 Script launcher
diff --git a/docs/source/quicktour.rst b/docs/source/quicktour.rst
index 31c94ef81..1d56f9e4b 100644
--- a/docs/source/quicktour.rst
+++ b/docs/source/quicktour.rst
@@ -359,7 +359,7 @@ The random number generator synchronization will by default synchronize:
 - the main random number generator in PyTorch <=1.5.1
 
 You can choose which random number generator(s) to synchronize with the :obj:`rng_types` argument of the main
-:class:`~accelerate.Accelerator`. In PyTorch >= 1.6, it is recommended to rely on local :obj:`generator`s to avoid
+:class:`~accelerate.Accelerator`. In PyTorch >= 1.6, it is recommended to rely on local :obj:`generator` to avoid
 setting the same seed in the main random number generator in all processes.
 
 .. Warning::