Exercises week 42¶
Python Code can be found at https://github.uio.no/larsbog/FYS-STK4155
+October 13-17, 2025
+Date: Deadline is Friday October 17 at midnight
+Overarching aims of the exercises this week¶
The aim of the exercises this week is to train the neural network you implemented last week.
+To train neural networks, we use gradient descent, since there is no analytical expression for the optimal parameters. This means you will need to compute the gradient of the cost function wrt. the network parameters. And then you will need to implement some gradient method.
+You will begin by computing gradients for a network with one layer, then two layers, then any number of layers. Keeping track of the shapes and doing things step by step will be very important this week.
+We recommend that you do the exercises this week by editing and running this notebook file, as it includes some checks along the way that you have implemented the neural network correctly, and running small parts of the code at a time will be important for understanding the methods. If you have trouble running a notebook, you can run this notebook in google colab instead(https://colab.research.google.com/drive/1FfvbN0XlhV-lATRPyGRTtTBnJr3zNuHL#offline=true&sandboxMode=true), though we recommend that you set up VSCode and your python environment to run code like this locally.
+First, some setup code that you will need.
+import autograd.numpy as np # We need to use this numpy wrapper to make automatic differentiation work later
+from autograd import grad, elementwise_grad
+from sklearn import datasets
+import matplotlib.pyplot as plt
+from sklearn.metrics import accuracy_score
+
+
+# Defining some activation functions
+def ReLU(z):
+ return np.where(z > 0, z, 0)
+
+
+# Derivative of the ReLU function
+def ReLU_der(z):
+ return np.where(z > 0, 1, 0)
+
+
+def sigmoid(z):
+ return 1 / (1 + np.exp(-z))
+
+
+def mse(predict, target):
+ return np.mean((predict - target) ** 2)
+Exercise 1 - Understand the feed forward pass¶
a) Complete last weeks' exercises if you haven't already (recommended).
+Exercise 2 - Gradient with one layer using autograd¶
For the first few exercises, we will not use batched inputs. Only a single input vector is passed through the layer at a time.
+In this exercise you will compute the gradient of a single layer. You only need to change the code in the cells right below an exercise, the rest works out of the box. Feel free to make changes and see how stuff works though!
+a) If the weights and bias of a layer has shapes (10, 4) and (10), what will the shapes of the gradients of the cost function wrt. these weights and this bias be?
+b) Complete the feed_forward_one_layer function. It should use the sigmoid activation function. Also define the weigth and bias with the correct shapes.
+def feed_forward_one_layer(W, b, x):
+ z = W @ x + b
+ a = sigmoid(z)
+ return a
+
+
+def cost_one_layer(W, b, x, target):
+ predict = feed_forward_one_layer(W, b, x)
+ return mse(predict, target)
+
+
+x = np.random.rand(2)
+target = np.random.rand(3)
+
+W = np.random.rand(3, 2)
+b = np.random.rand(3)
+c) Compute the gradient of the cost function wrt. the weigth and bias by running the cell below. You will not need to change anything, just make sure it runs by defining things correctly in the cell above. This code uses the autograd package which uses backprogagation to compute the gradient!
+autograd_one_layer = grad(cost_one_layer, [0, 1])
+W_g, b_g = autograd_one_layer(W, b, x, target)
+print(W_g, b_g)
+[[-0.0012661 -0.00171951] + [-0.00421828 -0.00572891] + [ 0.00930977 0.01264372]] [-0.01193713 -0.03977107 0.08777494] ++
Exercise 3 - Gradient with one layer writing backpropagation by hand¶
Before you use the gradient you found using autograd, you will have to find the gradient "manually", to better understand how the backpropagation computation works. To do backpropagation "manually", you will need to write out expressions for many derivatives along the computation.
+We want to find the gradient of the cost function wrt. the weight and bias. This is quite hard to do directly, so we instead use the chain rule to combine multiple derivatives which are easier to compute.
+$$ +\frac{dC}{dW} = \frac{dC}{da}\frac{da}{dz}\frac{dz}{dW} +$$
+$$ +\frac{dC}{db} = \frac{dC}{da}\frac{da}{dz}\frac{dz}{db} +$$
+a) Which intermediary results can be reused between the two expressions?
+The derivatives $\frac{\mathrm d C}{\mathrm d a} \frac{\mathrm d a}{\mathrm d z}$ are the same in both expressions and can be reused.
+b) What is the derivative of the cost wrt. the final activation? You can use the autograd calculation to make sure you get the correct result. Remember that we compute the mean in mse.
+z = W @ x + b
+a = sigmoid(z)
+
+predict = a
+
+
+def mse_der(predict, target):
+ return 2 * (predict - target) / target.size
+
+
+print(mse_der(predict, target))
+
+cost_autograd = grad(mse, 0)
+print(cost_autograd(predict, target))
+[-0.06423077 -0.18044784 0.43834371] +[-0.06423077 -0.18044784 0.43834371] ++
c) What is the expression for the derivative of the sigmoid activation function? You can use the autograd calculation to make sure you get the correct result.
+def sigmoid_der(z):
+ return sigmoid(z) * (1 - sigmoid(z))
+
+
+print(sigmoid_der(z))
+
+sigmoid_autograd = elementwise_grad(sigmoid, 0)
+print(sigmoid_autograd(z))
+[0.18584758 0.22040205 0.20024227] +[0.18584758 0.22040205 0.20024227] ++
d) Using the two derivatives you just computed, compute this intermetidary gradient you will use later:
+$$ +\frac{dC}{dz} = \frac{dC}{da}\frac{da}{dz} +$$
+dC_da = mse_der(predict, target)
+dC_dz = dC_da * sigmoid_der(z)
+e) What is the derivative of the intermediary z wrt. the weight and bias? What should the shapes be? The one for the weights is a little tricky, it can be easier to play around in the next exercise first. You can also try computing it with autograd to get a hint.
+f) Now combine the expressions you have worked with so far to compute the gradients! Note that you always need to do a feed forward pass while saving the zs and as before you do backpropagation, as they are used in the derivative expressions
+x, dC_dz
+(array([0.10606414, 0.14404709]), + array([-0.01193713, -0.03977107, 0.08777494]))+
dC_da = mse_der(predict, target)
+dC_dz = dC_da * sigmoid_der(z)
+dC_dW = np.outer(dC_dz, x)
+dC_db = dC_dz
+
+print(dC_dW, dC_db)
+[[-0.0012661 -0.00171951] + [-0.00421828 -0.00572891] + [ 0.00930977 0.01264372]] [-0.01193713 -0.03977107 0.08777494] ++
You should get the same results as with autograd.
+W_g, b_g = autograd_one_layer(W, b, x, target)
+print(W_g, b_g)
+[[-0.0012661 -0.00171951] + [-0.00421828 -0.00572891] + [ 0.00930977 0.01264372]] [-0.01193713 -0.03977107 0.08777494] ++
Exercise 4 - Gradient with two layers writing backpropagation by hand¶
+Now that you have implemented backpropagation for one layer, you have found most of the expressions you will need for more layers. Let's move up to two layers.
+x = np.random.rand(2)
+target = np.random.rand(4)
+
+W1 = np.random.rand(3, 2)
+b1 = np.random.rand(3)
+
+W2 = np.random.rand(4, 3)
+b2 = np.random.rand(4)
+
+layers = [(W1, b1), (W2, b2)]
+z1 = W1 @ x + b1
+a1 = sigmoid(z1)
+z2 = W2 @ a1 + b2
+a2 = sigmoid(z2)
+We begin by computing the gradients of the last layer, as the gradients must be propagated backwards from the end.
+a) Compute the gradients of the last layer, just like you did the single layer in the previous exercise.
+dC_da2 = mse_der(a2, target)
+dC_dz2 = dC_da2 * sigmoid_der(z2)
+dC_dW2 = np.outer(dC_dz2, a1)
+dC_db2 = dC_dz2
+To find the derivative of the cost wrt. the activation of the first layer, we need a new expression, the one furthest to the right in the following.
+$$ +\frac{dC}{da_1} = \frac{dC}{dz_2}\frac{dz_2}{da_1} +$$
+b) What is the derivative of the second layer intermetiate wrt. the first layer activation? (First recall how you compute $z_2$)
+$$ +\frac{dz_2}{da_1} +$$
+dz2_da1 = W2.T
+c) Use this expression, together with expressions which are equivelent to ones for the last layer to compute all the derivatives of the first layer.
+$$ +\frac{dC}{dW_1} = \frac{dC}{da_1}\frac{da_1}{dz_1}\frac{dz_1}{dW_1} +$$
+$$ +\frac{dC}{db_1} = \frac{dC}{da_1}\frac{da_1}{dz_1}\frac{dz_1}{db_1} +$$
+dC_da1 = dz2_da1 @ dC_dz2
+dC_dz1 = dC_da1 * sigmoid_der(z1)
+dC_dW1 = np.outer(dC_dz1, x)
+dC_db1 = dC_dz1
+print(dC_dW1, dC_db1)
+print(dC_dW2, dC_db2)
+[[0.00446139 0.00071062] + [0.00983449 0.00156645] + [0.0024775 0.00039462]] [0.00524627 0.01156463 0.00291336] +[[ 0.03644459 0.02409418 0.03224462] + [ 0.05648327 0.03734211 0.04997399] + [-0.00813619 -0.00537898 -0.00719855] + [ 0.0034844 0.0023036 0.00308285]] [ 0.04508103 0.06986838 -0.01006426 0.00431011] ++
d) Make sure you got the same gradient as the following code which uses autograd to do backpropagation.
+def feed_forward_two_layers(layers, x):
+ W1, b1 = layers[0]
+ z1 = W1 @ x + b1
+ a1 = sigmoid(z1)
+
+ W2, b2 = layers[1]
+ z2 = W2 @ a1 + b2
+ a2 = sigmoid(z2)
+
+ return a2
+def cost_two_layers(layers, x, target):
+ predict = feed_forward_two_layers(layers, x)
+ return mse(predict, target)
+
+
+grad_two_layers = grad(cost_two_layers, 0)
+grad_two_layers(layers, x, target)
+[(array([[0.00446139, 0.00071062], + [0.00983449, 0.00156645], + [0.0024775 , 0.00039462]]), + array([0.00524627, 0.01156463, 0.00291336])), + (array([[ 0.03644459, 0.02409418, 0.03224462], + [ 0.05648327, 0.03734211, 0.04997399], + [-0.00813619, -0.00537898, -0.00719855], + [ 0.0034844 , 0.0023036 , 0.00308285]]), + array([ 0.04508103, 0.06986838, -0.01006426, 0.00431011]))]+
e) How would you use the gradient from this layer to compute the gradient of an even earlier layer? Would the expressions be any different?
+Exercise 5 - Gradient with any number of layers writing backpropagation by hand¶
+Well done on getting this far! Now it's time to compute the gradient with any number of layers.
+First, some code from the general neural network code from last week. Note that we are still sending in one input vector at a time. We will change it to use batched inputs later.
+def create_layers(network_input_size, layer_output_sizes):
+ layers = []
+
+ i_size = network_input_size
+ for layer_output_size in layer_output_sizes:
+ W = np.random.randn(layer_output_size, i_size)
+ b = np.random.randn(layer_output_size)
+ layers.append((W, b))
+
+ i_size = layer_output_size
+ return layers
+
+
+def feed_forward(input, layers, activation_funcs):
+ a = input
+ for (W, b), activation_func in zip(layers, activation_funcs):
+ z = W @ a + b
+ a = activation_func(z)
+ return a
+
+
+def cost(layers, input, activation_funcs, target):
+ predict = feed_forward(input, layers, activation_funcs)
+ return mse(predict, target)
+You might have already have noticed a very important detail in backpropagation: You need the values from the forward pass to compute all the gradients! The feed forward method above is great for efficiency and for using autograd, as it only cares about computing the final output, but now we need to also save the results along the way.
+Here is a function which does that for you.
+def feed_forward_saver(input, layers, activation_funcs):
+ layer_inputs = []
+ zs = []
+ a = input
+ for (W, b), activation_func in zip(layers, activation_funcs):
+ layer_inputs.append(a)
+ z = W @ a + b
+ a = activation_func(z)
+
+ zs.append(z)
+
+ return layer_inputs, zs, a
+a) Now, complete the backpropagation function so that it returns the gradient of the cost function wrt. all the weigths and biases. Use the autograd calculation below to make sure you get the correct answer.
+def backpropagation(
+ input, layers, activation_funcs, target, activation_ders, cost_der=mse_der
+):
+ layer_inputs, zs, predict = feed_forward_saver(input, layers, activation_funcs)
+
+ layer_grads = [() for layer in layers]
+
+ # We loop over the layers, from the last to the first
+ for i in reversed(range(len(layers))):
+ layer_input, z, activation_der = layer_inputs[i], zs[i], activation_ders[i]
+
+ if i == len(layers) - 1:
+ # For last layer we use cost derivative as dC_da(L) can be computed directly
+ dC_da = cost_der(predict, target)
+ else:
+ # For other layers we build on previous z derivative, as dC_da(i) = dC_dz(i+1) * dz(i+1)_da(i)
+ (W, b) = layers[i + 1]
+ dC_da = W.T @ dC_dz
+
+ dC_dz = dC_da * activation_der(z)
+ dC_dW = np.outer(dC_dz, layer_input)
+ dC_db = dC_dz
+
+ layer_grads[i] = (dC_dW, dC_db)
+
+ return layer_grads
+network_input_size = 2
+layer_output_sizes = [3, 4]
+activation_funcs = [sigmoid, ReLU]
+activation_ders = [sigmoid_der, ReLU_der]
+
+layers = create_layers(network_input_size, layer_output_sizes)
+
+x = np.random.rand(network_input_size)
+target = np.random.rand(4)
+layer_grads = backpropagation(x, layers, activation_funcs, target, activation_ders)
+print(layer_grads)
+[(array([[0.02299964, 0.09565439], + [0.01274242, 0.05299513], + [0.01038055, 0.04317222]]), array([0.09661863, 0.05352934, 0.04360741])), (array([[-0. , -0. , -0. ], + [ 0.23150223, 0.16003629, 0.36267149], + [-0. , -0. , -0. ], + [-0.20226612, -0.13982552, -0.31687019]]), array([-0. , 0.41494126, -0. , -0.36253888]))] ++
cost_grad = grad(cost, 0)
+cost_grad(layers, x, [sigmoid, ReLU], target)
+[(array([[0.02299964, 0.09565439], + [0.01274242, 0.05299513], + [0.01038055, 0.04317222]]), + array([0.09661863, 0.05352934, 0.04360741])), + (array([[ 0. , 0. , 0. ], + [ 0.23150223, 0.16003629, 0.36267149], + [ 0. , 0. , 0. ], + [-0.20226612, -0.13982552, -0.31687019]]), + array([ 0. , 0.41494126, 0. , -0.36253888]))]+
Exercise 6 - Batched inputs¶
Make new versions of all the functions in exercise 5 which now take batched inputs instead. See last weeks exercise 5 for details on how to batch inputs to neural networks. You will also need to update the backpropogation function.
+def feed_forward_saver_batch(input, layers, activation_funcs):
+ layer_inputs = []
+ zs = []
+ a = input
+ for (W, b), activation_func in zip(layers, activation_funcs):
+ layer_inputs.append(a)
+ z = a @ W.T + b
+ a = activation_func(z)
+
+ zs.append(z)
+
+ return layer_inputs, zs, a
+
+def backpropagation_batch(
+ input, layers, activation_funcs, target, activation_ders, cost_der=mse_der
+):
+ layer_inputs, zs, predict = feed_forward_saver_batch(input, layers, activation_funcs)
+
+ layer_grads = [() for layer in layers]
+
+ # We loop over the layers, from the last to the first
+ for i in reversed(range(len(layers))):
+ layer_input, z, activation_der = layer_inputs[i], zs[i], activation_ders[i]
+
+ if i == len(layers) - 1:
+ # For last layer we use cost derivative as dC_da(L) can be computed directly
+ dC_da = cost_der(predict, target)
+ else:
+ # For other layers we build on previous z derivative, as dC_da(i) = dC_dz(i+1) * dz(i+1)_da(i)
+ (W, b) = layers[i + 1]
+ dC_da = (W.T @ dC_dz.T).T
+
+ # print(f"Layer {i}: dC_da shape: {dC_da.shape}, dC_dz shape: {dC_dz.shape if 'dC_dz' in locals() else 'N/A'}, layer_input shape: {layer_input.shape}")
+ dC_dz = dC_da * activation_der(z)
+ # print(dC_dz.shape)
+ dC_dW = dC_dz.T @ layer_input
+ dC_db = np.mean(dC_dz, axis=0)
+
+ layer_grads[i] = (dC_dW, dC_db)
+
+ return layer_grads
+
+x = np.random.rand(150, network_input_size)
+target = np.random.rand(150, 4)
+
+layer_grads = backpropagation_batch(x, layers, activation_funcs, target, activation_ders)
+layer_grads[0][0].shape, layer_grads[0][1].shape
+((3, 2), (3,))+
Exercise 7 - Training¶
+a) Complete exercise 6 and 7 from last week, but use your own backpropogation implementation to compute the gradient.
+-
+
- IMPORTANT: Do not implement the derivative terms for softmax and cross-entropy separately, it will be very hard! +
- Instead, use the fact that the derivatives multiplied together simplify to prediction - target (see source1, source2) +
b) Use stochastic gradient descent with momentum when you train your network.
+class GradientDescent:
+ def __init__(
+ self, *args, learning_rate: float = 0.1, num_iterations: int = 1000, **kwargs
+ ):
+ """Gradient Descent Class
+
+ Args:
+ learning_rate (float, optional): Learning rate used for step updates. Defaults to 0.1.
+ num_iterations (int, optional): Number of iterations for gradient descent. Defaults to 1000.
+ """
+ self._cost_history = np.zeros(num_iterations)
+ self.learning_rate = learning_rate
+ self.num_iterations = num_iterations
+
+ @property
+ def cost_history(self) -> np.ndarray:
+ """Returns the cost history of the optimization process.
+
+ Returns:
+ np.ndarray: Array of cost values for each iteration.
+ """
+ return self._cost_history
+
+ def get_epochs(self) -> np.ndarray:
+ """Returns an array of epoch numbers from 0 to num_iterations - 1.
+
+ Returns:
+ np.ndarray: Array of epoch numbers.
+ """
+ return np.arange(self.num_iterations)
+
+ def fit(self, X: np.ndarray, y: np.ndarray) -> np.ndarray:
+ """Returns the optimal solution for an optimization problem using the gradient descent
+
+ Args:
+ X (np.ndarray): X values
+ y (np.ndarray): y values
+
+ Returns:
+ np.ndarray: Optimal parameters
+ """
+ self.X = X
+ self.y = y
+ self.theta = np.zeros(X.shape[1])
+ self._precomp()
+ for t in range(self.num_iterations):
+ self._comp_step()
+ self._cost_history[t] = self._compute_cost()
+ self._update_theta()
+ return self.theta
+
+ def _precomp(self):
+ pass
+
+ def _comp_step(self):
+ pass
+
+ def _compute_cost(self):
+ pass
+
+ def _update_theta(self):
+ pass
+
+
+def cost(input, layers, activation_funcs, target):
+ predict = feed_forward_batch(input, layers, activation_funcs)
+ return mse(predict, target)
+
+class NNGradientDescent(GradientDescent):
+ def __init__(self, *args, layers, activation_funcs, activation_ders, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.layers = layers
+ self.activation_funcs = activation_funcs
+ self.activation_ders = activation_ders
+
+
+ def _precomp(self):
+ pass
+
+ def _comp_step(self):
+ self.layer_inputs, self.zs, self.predict = feed_forward_saver_batch(self.X, self.layers, self.activation_funcs)
+
+ def _compute_cost(self) -> float:
+ return mse(self.predict, self.y)
+
+ def _compute_grad(self) -> list[tuple[np.ndarray, np.ndarray]]:
+ layer_grads = backpropagation_batch(
+ self.X, self.layers, self.activation_funcs, self.y, self.activation_ders
+ )
+ return layer_grads
+
+ def _update_theta(self):
+ for i, (dC_dW, dC_db) in enumerate(self._compute_grad()):
+ W, b = self.layers[i]
+ W -= self.learning_rate * dC_dW
+ b -= self.learning_rate * dC_db
+ self.layers[i] = (W, b)
+
+
+class NNStochasticGradientDescent(NNGradientDescent):
+ def __init__(
+ self, *args, batch_size: int = 100, batches_per_epoch: int = 1, **kwargs
+ ):
+ # print(self.__class__.__name__) # If you see this: debugging yaaaay, the programmer that wrote this line is stupid...
+ super().__init__(*args, **kwargs)
+ self.batch_size = batch_size
+ self.batches_per_epoch = batches_per_epoch
+ self.RNG = np.random.default_rng(seed=42)
+
+ def _precomp(self):
+ self.N = len(self.y)
+ self.indices = np.arange(self.N)
+ self.n = self.batch_size
+ self.RNG.shuffle(self.indices)
+ self.X = self.X[self.indices]
+ self.y = self.y[self.indices]
+
+ def _comp_step(self):
+ index = self.RNG.integers(0, self.N)
+ batch_indices = slice(index, index + self.batch_size)
+ if index + self.batch_size > self.N:
+ batch_indices = slice(index, self.N)
+
+ X_batch = self.X[batch_indices]
+ y_batch = self.y[batch_indices]
+ self.layer_inputs, self.zs, self.predict = feed_forward_saver_batch(X_batch, self.layers, self.activation_funcs)
+ self.X_batch = X_batch
+ self.y_batch = y_batch
+
+ def _compute_cost(self) -> float:
+ return mse(self.predict, self.y_batch)
+
+ def _compute_grad(self) -> list[tuple[np.ndarray, np.ndarray]]:
+ layer_grads = backpropagation_batch(
+ self.X_batch, self.layers, self.activation_funcs, self.y_batch, self.activation_ders
+ )
+ return layer_grads
+
+ def get_epochs(self):
+ return np.arange(self.num_iterations // self.batches_per_epoch)
+
+ @property
+ def cost_history(self) -> np.ndarray:
+ """Returns the cost history of the optimization process.
+
+ Returns:
+ np.ndarray: Array of cost values for each epoch.
+ """
+ return np.mean(self._cost_history.reshape(-1, self.batches_per_epoch), axis=1)
+
+class NNMomentum(NNGradientDescent):
+ def __init__(self, *args, delta: float = 1.0, **kwargs):
+ super().__init__(*args, **kwargs)
+ self.delta = delta
+
+ def _precomp(self):
+ self.last_layers = [(np.zeros_like(W), np.zeros_like(b)) for W, b in self.layers]
+ return super()._precomp()
+
+ def _update_theta(self):
+ self.last_layers = [(W.copy(), b.copy()) for W, b in self.layers]
+ for i, ((W, b), (W_prev, b_prev), (dW, db)) in enumerate(zip(self.layers, self.last_layers, self._compute_grad())):
+ W = self.delta * (W - W_prev) - self.learning_rate * dW
+ b = self.delta * (b - b_prev) - self.learning_rate * db
+ self.layers[i] = (W, b)
+
+class NNMomentumSGD(NNMomentum, NNStochasticGradientDescent):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+
+
+opt = NNMomentumSGD(layers=layers, activation_funcs=activation_funcs, activation_ders=activation_ders, learning_rate=0.01, num_iterations=1000, batch_size=32, batches_per_epoch=10)
+_ = opt.fit(x, target)
+
+import matplotlib.pyplot as plt
+
+plt.plot(opt.get_epochs(), opt.cost_history)
+[<matplotlib.lines.Line2D at 0x7f2db9fc87d0>]+
+Exercise 8 (Optional) - Object orientation¶
Passing in the layers, activations functions, activation derivatives and cost derivatives into the functions each time leads to code which is easy to understand in isoloation, but messier when used in a larger context with data splitting, data scaling, gradient methods and so forth. Creating an object which stores these values can lead to code which is much easier to use.
+a) Write a neural network class. You are free to implement it how you see fit, though we strongly recommend to not save any input or output values as class attributes, nor let the neural network class handle gradient methods internally. Gradient methods should be handled outside, by performing general operations on the layer_grads list using functions or classes separate to the neural network.
+We provide here a skeleton structure which should get you started.
+class NeuralNetwork:
+ def __init__(
+ self,
+ network_input_size,
+ layer_output_sizes,
+ activation_funcs,
+ activation_ders,
+ cost_fun,
+ cost_der,
+ ):
+ pass
+
+ def predict(self, inputs):
+ # Simple feed forward pass
+ pass
+
+ def cost(self, inputs, targets):
+ pass
+
+ def _feed_forward_saver(self, inputs):
+ pass
+
+ def compute_gradient(self, inputs, targets):
+ pass
+
+ def update_weights(self, layer_grads):
+ pass
+
+ # These last two methods are not needed in the project, but they can be nice to have! The first one has a layers parameter so that you can use autograd on it
+ def autograd_compliant_predict(self, layers, inputs):
+ pass
+
+ def autograd_gradient(self, inputs, targets):
+ pass
+