diff --git a/README.md b/README.md
index 219b93248..68d6866b5 100644
--- a/README.md
+++ b/README.md
@@ -52,36 +52,23 @@ limitations under the License.
 
 Here is an example:
 
-<table>
-<tr>
-<th> Original training code <br> (CPU or mono-GPU only)</th>
-<th> With Accelerate <br> (CPU/GPU/multi-GPUs/TPUs/fp16) </th>
-</tr>
-<tr>
-<td>
-
-```python
+```diff
 import torch
 import torch.nn.functional as F
 from datasets import load_dataset
 
-
-
-device = 'cpu'
++ from accelerate import Accelerator
++ accelerator = Accelerator()
+- device = 'cpu'
++ device = accelerator.device
 
 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
-)
-
-
-
+data = torch.utils.data.Dataloader(dataset)
 
++ model, optim, data = accelerator.prepare(model, optim, data)
 
 model.train()
 for epoch in range(10):
@@ -92,166 +79,55 @@ for epoch in range(10):
         optimizer.zero_grad()
 
         output = model(source, targets)
-        loss = F.cross_entropy(
-            output, targets
-        )
-
-        loss.backward()
-
-        optimizer.step()
-```
-
-</td>
-<td>
-
-```python
-  import torch
-  import torch.nn.functional as F
-  from datasets import load_dataset
-
-+ from accelerate import Accelerator
-+ accelerator = Accelerator()
-+ device = accelerator.device
-
-  model = torch.nn.Transformer().to(device)
-  optim = torch.optim.Adam(
-      model.parameters()
-  )
-
-  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)
-
-          optimizer.zero_grad()
-
-          output = model(source, targets)
-          loss = F.cross_entropy(
-              output, targets
-          )
+        loss = F.cross_entropy(output, targets)
 
 +         accelerator.backward(loss)
+-         loss.backward()
 
-          optimizer.step()
+        optimizer.step()
 ```
 
-</td>
-</tr>
-</table>
-
 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).
 
 In particular, the same code can then be run without modification on your local machine for debugging or your training environment.
 
 🤗 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:
 
-<table>
-<tr>
-<th> Original training code <br> (CPU or mono-GPU only)</th>
-<th> With Accelerate <br> (CPU/GPU/multi-GPUs/TPUs/fp16) </th>
-</tr>
-<tr>
-<td>
-
-```python
+```diff
 import torch
 import torch.nn.functional as F
 from datasets import load_dataset
 
++ from accelerate import Accelerator
++ accelerator = Accelerator()
+- device = 'cpu'
 
-
-device = 'cpu'
-
-model = torch.nn.Transformer().to(device)
-optim = torch.optim.Adam(
-    model.parameters()
-)
++ model = torch.nn.Transformer()
+- model = torch.nn.Transformer().to(device)
+optim = torch.optim.Adam(model.parameters())
 
 dataset = load_dataset('my_dataset')
-data = torch.utils.data.Dataloader(
-    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)
+-         source = source.to(device)
+-         targets = targets.to(device)
 
         optimizer.zero_grad()
 
         output = model(source, targets)
-        loss = F.cross_entropy(
-            output, targets
-        )
-
-        loss.backward()
-
-        optimizer.step()
-```
-
-</td>
-<td>
-
-```python
-  import torch
-  import torch.nn.functional as F
-  from datasets import load_dataset
-
-+ from accelerate import Accelerator
-+ accelerator = Accelerator()
--
-
-+ model = torch.nn.Transformer()
-  optim = torch.optim.Adam(
-      model.parameters()
-  )
-
-  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:
--
--
-
-          optimizer.zero_grad()
-
-          output = model(source, targets)
-          loss = F.cross_entropy(
-              output, targets
-          )
+        loss = F.cross_entropy(output, targets)
 
 +         accelerator.backward(loss)
+-         loss.backward()
 
-          optimizer.step()
+        optimizer.step()
 ```
 
-</td>
-</tr>
-</table>
-
 ## Launching script
 
 🤗 Accelerate also provides an optional CLI tool that allows you to quickly configure and test your training environment before launching the scripts. No need to remember how to use `torch.distributed.launch` or to write a specific launcher for TPU training!