Fix code highlight

Author: curiousily

manuscript/04.first-neural-network.md

@@ -140,7 +140,7 @@ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_
 
 And convert all of it to Tensors (so we can use it with PyTorch):
 
-```
+```py
 X_train = torch.from_numpy(X_train.to_numpy()).float()
 y_train = torch.squeeze(torch.from_numpy(y_train.to_numpy()).float())
 
@@ -181,7 +181,7 @@ class Net(nn.Module):
     return torch.sigmoid(self.fc3(x))
 ```
 
-```
+```py
 net = Net(X_train.shape[1])
 
 ann_viz(net, view=False)
@@ -207,13 +207,13 @@ Those functions must be hard to define, right?
 
 Not at all, let start with the ReLU definition (one of the most widely used activation function):
 
-$$
+{$$}
 \text{ReLU}(x) = \max({0, x})
-$$
+{/$$}
 
 Easy peasy, the result is the maximum value of zero and the input.
 
-```
+```py
 ax = plt.gca()
 
 plt.plot(
@@ -231,11 +231,13 @@ The sigmoid is useful when you need to make a binary decision/classification (an
 
 It is defined as:
 
-$$\text{Sigmoid}(x) = \frac{1}{1+e^{-x}}$$
+{$$}
+\text{Sigmoid}(x) = \frac{1}{1+e^{-x}}
+{/$$}
 
 The sigmoid squishes the input values between 0 and 1. But in a super kind of way:
 
-```
+```py
 ax = plt.gca()
 
 plt.plot(
@@ -251,7 +253,7 @@ ax.set_ylim([-1.5, 1.5]);
 
 With the model in place, we need to find parameters that predict will it rain tomorrow. First, we need something to tell us how good we're currently doing:
 
-```
+```py
 criterion = nn.BCELoss()
 ```
 
@@ -269,7 +271,7 @@ Contrary to what you might believe, optimization in Deep Learning is just satisf
 
 While there are tons of optimizers you can choose from, [Adam](https://pytorch.org/docs/stable/optim.html#torch.optim.Adam) is a safe first choice. PyTorch has a well-debugged implementation you can use:
 
-```
+```py
 optimizer = optim.Adam(net.parameters(), lr=0.001)
 ```
 
@@ -281,19 +283,19 @@ Doing massively parallel computations on GPUs is one of the enablers for modern
 
 PyTorch makes it really easy to transfer all the computation to your GPU:
 
-```
+```py
 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 ```
 
-```
+```py
 X_train = X_train.to(device)
 y_train = y_train.to(device)
 
 X_test = X_test.to(device)
 y_test = y_test.to(device)
 ```
 
-```
+```py
 net = net.to(device)
 
 criterion = criterion.to(device)
@@ -305,7 +307,7 @@ We start by checking whether or not a CUDA device is available. Then, we transfe
 
 Having a loss function is great, but tracking the accuracy of our model is something easier to understand, for us mere mortals. Here's the definition for our accuracy:
 
-```
+```py
 def calculate_accuracy(y_true, y_pred):
   predicted = y_pred.ge(.5).view(-1)
   return (y_true == predicted).sum().float() / len(y_true)
@@ -315,7 +317,7 @@ We convert every value below 0.5 to 0. Otherwise, we set it to 1. Finally, we ca
 
 With all the pieces of the puzzle in place, we can start training our model:
 
-```
+```py
 def round_tensor(t, decimal_places=3):
   return round(t.item(), decimal_places)
 
@@ -398,18 +400,15 @@ What about that accuracy? 83.6% accuracy on the test set sounds reasonable, righ
 
 Training a good model can take a lot of time. And I mean weeks, months or even years. So, let's make sure that you know how you can save your precious work. Saving is easy:
 
-```
+```py
 MODEL_PATH = 'model.pth'
 
 torch.save(net, MODEL_PATH)
 ```
 
-    /usr/local/lib/python3.6/dist-packages/torch/serialization.py:360: UserWarning: Couldn't retrieve source code for container of type Net. It won't be checked for correctness upon loading.
-      "type " + obj.__name__ + ". It won't be checked "
-
 Restoring your model is easy too:
 
-```
+```py
 net = torch.load(MODEL_PATH)
 ```
 
@@ -421,7 +420,7 @@ Using just accuracy wouldn't be a good way to do it. Recall that our data contai
 
 One way to delve a bit deeper into your model performance is to assess the precision and recall for each class. In our case, that will be _no rain_ and _rain_:
 
-```
+```py
 classes = ['No rain', 'Raining']
 
 y_pred = net(X_test)
@@ -447,7 +446,7 @@ You can see that our model is doing good when it comes to the _No rain_ class. W
 
 One of the best things about binary classification is that you can have a good look at a simple confusion matrix:
 
-```
+```py
 cm = confusion_matrix(y_test, y_pred)
 df_cm = pd.DataFrame(cm, index=classes, columns=classes)