# Import the necessary libraries

import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np

# Read the file 'backprop.csv'

df = pd.read_csv('backprop.csv')

#Generating the predictor and response data 
x = df.x.values.reshape(-1,1)
y = df.y.values

# Initialize the weights and use the same random seed as the previous exercise i.e. 310
np.random.seed(310)
W = [np.random.randn(1, 1), np.random.randn(1, 1)]

# Function to compute the activation function
def A(x):
    return ___

# Function to compute the derivative of the activation function
def der_A(x):
    return ___

# Defining a simple neural network we used in the previous exercise

def neural_network(W, x):
    
    # Computing the first affine
    a1 = np.dot(x, W[0])
    
    # Defining sin() as the activation function
    fa1 = A(a1)
    
    # Computing the second affine
    a2 = np.dot(fa1,W[1])
    
    # Defining sin() as the activation function
    y = A(a2)
    
    return a1,a2,y

#Use the helper code below to plot the true data and the predictions of your neural network

fig,ax = plt.subplots(1,1,figsize=(8,6))
ax.plot(x,y,label = 'True Function',color='darkblue',linewidth=2)
ax.plot(x,neural_network(W,x)[2],label = 'Neural Network Predictions',color='#9FC131FF',linewidth=2)
ax.set_xlabel('$x$',fontsize=14)
ax.set_ylabel('$y$',fontsize=14)
ax.legend(fontsize=14, loc='best');

# Function to compute the partial derivate of a (particular neuron) with respect to corresponding weight w

def dadw(x,firstweight=0):
    '''
    The derivative of the 'a' wrt the preceding weight is just the activation of the previous neuron
    Note, account for the case where the input layer has no activation layers associated with it. i.e return x if its the first weight 
    '''
    if firstweight == 1:
        return ___
    return ___

# Function to compute the partial derivate of h with respect to a

def dhda(a):
    '''
    This is the derivative of the output of the activation function wrt the affine transformation.
    Return the derivative of the activation of the affine transformation
    '''
    
    return ___

# Function to compute the partial derivate of y with respect to a

def dyda(a):
    '''
    This is the derivative of the output of the neural network wrt the affine transformation.
    Return the derivative of the activation of the affine transformation
    '''
    
    return ___

# Function to compute the partial derivate of a with respect to h
def dadh(w):
    
    return ___

# Function to compute the partial derivate of loss with respect to y
def dldy(y_pred,y):
    '''
    Since our loss function is the MSE,
    The partial derivative of L wrt y will be 2*(y_pred - y), for all predictions and response
    '''
    
    return ___

# Function to compute the partial derivate of loss with respect to w

def dldw(W,x):
    
    '''
    Now, combine the functions from above and find the derivative wrt weights.
    These will be for all the points, hence take a mean of all values for each partial derivative and return as a list of 2 values
    
    '''
    dldw2 = ____
    dldw1 = ____
    
    return [np.mean(dldw2),np.mean(dldw1)]

### edTest(test_gradient) ###

# Get the predicted response, and the two activations of the network
a1, a2, y_pred = neural_network(W,x)

# Compute the gradient of the loss function with respect to the weights using function defined above
gradW = dldw(W,x)

# Print the list of your gradients below
print(f'The derivatives of w1 w2 wrt L are {gradW}')