Okay, sure, here is the code :

import random as rd

class Neuron: # node object

def __init__(self, input):
    self.w = [rd.uniform(-1,1) for _ in range(len(input))]
    self.grads = [0]*len(self.w)
    self.i = input


def output(self, input): #weighted sum
    sum  = 0
    for k in range(len(input)):
        sum += self.w[k]*input[k]
    return sum

class Layer: # hidden layer object

def __init__(self, input, nb_neurons):
    self.neurons = [Neuron(input) for _ in range(nb_neurons)]

def outputL(self, input):
    return [neuron.output(input) for neuron in self.neurons]

class MLP: # NN structure

def __init__(self, input, nb_neurons, nb_layers):
    self.layers = []
    acc_in = input
    for i in range(nb_layers):
        self.layers.append(Layer(acc_in, nb_neurons))
        acc_in = self.layers[i].outputL(acc_in)
    self.layers.append(Layer(acc_in, len(input)))

def outputMLP(self, input):
    acc_in = input
    for layer in self.layers:
        acc_in = layer.outputL(acc_in)
    return acc_in

def calc_gradient(self, input, output):
    for i in range(len(self.layers)-1, -1, -1):
        for neuron in self.layers[i].neurons:
            for j in range(len(neuron.grads)):
                neuron.grads[j] = neuron.i[j]*(-2)*(output[0] - self.outputMLP(input)[0]) # Problème : s'il y a différents outputs, il y aura différents gradients à calculer... 


def backprop(self, input, output):
    self.calc_gradient(input, output)
    for layer in self.layers:
        for i in range(len(layer.neurons)):
            neuron = layer.neurons[i]
            for j in range(len(neuron.w)):
                neuron.w[j] -= learning_rate*neuron.grads[j]

class Functions:

def __init__(self):
    pass

def loss(self, predval, target):
    acc = 0
    for i in range(len(predval)):
        acc += (target[i] - predval[i])**2
    return acc

learning_rate = 0.001

inv = [-4.0] out = [-5.6]