python_正則化のコーディング

前提・実現したいこと

初めて投稿させていただきます。
AIの資格取得のため、講義を受けているのですが、
出題されたコーディング問題の解き方が分からず困っております。
解説もいただいているのですが、pythonプログラミングは初心者なので、
よくわからず投稿させていただきました。
以下解説内容

「【問①-1】：lp_norm関数の引数には、「それぞれの全結合層の重みw」を渡します。 for文のfcを用いて、FullyConnectedLayerクラスのインスタンス変数self.wにアクセスするような処理が必要です。【問①-2】：L2正則化の逆伝播は定義の微分、つまりλ＊wとなります。」

うまく質問できていなかったらすみません。

発生している問題・エラーメッセージ

エラーメッセージ

該当のソースコード

# mnistデータセットのロード
if os.path.exists('mnist_784'):
    with open('mnist_784','rb') as f:
        mnist = pickle.load(f)
else:
    mnist = datasets.fetch_openml('mnist_784')
    with open('mnist_784', 'wb') as f:
        pickle.dump(mnist, f)
    
X, T = mnist.data, mnist.target
X_train, X_test, T_train, T_test = train_test_split(X, T, test_size=0.2)
T_train = np.eye(10)[T_train.astype("int")]
T_test = np.eye(10)[T_test.astype("int")]


class FullyConnectedLayer():
    def __init__(self, input_shape, output_shape):
        self.w = np.random.randn(input_shape, output_shape) * 0.01
        self.b = np.zeros(output_shape, dtype=np.float)
        self.x = None
        self.dw = None
        self.db = None
        
    def __call__(self, x):
        self.x = x
        out = np.dot(self.x, self.w) + self.b
        return out
    
    def backward(self, dout):
        dx = np.dot(dout, self.w.T)
        batch_size = dx.shape[0]
        self.dw = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)
        return dx


class SoftmaxCrossEntropyLoss():
    def __init__(self):
        self.y = None
        self.t = None
        self.loss = None
        
    def __call__(self, t, y):
        self.y = softmax(y)
        self.t = t.copy()
        self.loss = cross_entropy_error(self.t, self.y)
        return self.loss
    
    def backward(self):
        batch_size = self.t.shape[0]
        dy = self.y - self.t
        dy /= batch_size
        return dy


def softmax(x):
    x = x.T
    _x = x - np.max(x, axis=0)
    _x = np.exp(_x) / np.sum(np.exp(_x), axis=0)
    return _x.T


def cross_entropy_error(t, y):
    delta = 1e-8
    error = -np.mean(t * np.log(y + delta))
    return error


class ReLU():
    def __init__(self):
        self.mask = None

    def __call__(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0
        return out

    def backward(self, dout):
        dout[self.mask] = 0
        dx = dout

        return dx


class Dropout():
    def __init__(self, dropout_ratio=0.5):
        self.dropout_ratio = dropout_ratio
        self.mask = None

    def __call__(self, x, train_flg=True):
        if train_flg:
            randommatrix = np.random.rand(*x.shape)
            self.mask = randommatrix > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

    def backward(self, dout):
        return dout * self.mask



def lp_norm(x, p=2):
    return np.sum(np.abs(x) ** p) ** (1 / p)


#ここからが問題
#問①. dropoutクラスとlp_norm関数を使用し、ドロップアウトとL2ノルム正則化（重み減衰）を含めた以下のネットワークを完成させなさい。
#損失関数に  ????2‖????‖22 を正則化項として加えるとする.

class MLP_classifier():

    def __init__(self, weight_decay_lambda=0):
        '''
        構造
        x -> fc(783, 256) -> relu -> dropout -> fc(256, 256) -> relu -> dropout -> fc(256, 10) -> out
        '''
        
        # 層の定義
        self.fc1 = FullyConnectedLayer(784, 256)
        self.relu1 = ReLU()
        self.dropout1 = Dropout()
        self.fc2 = FullyConnectedLayer(256, 256)
        self.relu2 = ReLU()
        self.dropout2 = Dropout()
        self.fc3 = FullyConnectedLayer(256, 10)
        self.out = None
        
        # 損失関数の定義
        self.criterion = SoftmaxCrossEntropyLoss()
        self.weight_decay_lambda = weight_decay_lambda

    def forward(self, x, train_flg=True):
        '''
        順伝播
        '''
        
        x = self.relu1(self.fc1(x))
        x = self.dropout1(x, train_flg)
        x = self.relu2(self.fc2(x))
        x = self.dropout2(x, train_flg)
        self.out = self.fc3(x)
        
        # 勾配計算の都合上softmaxはこの順伝播関数内では行わない
        # 予測するときはさらにsoftmaxを通す必要がある
        return self.out
    
    def loss(self, x, t):
        loss = self.criterion(t, self.forward(x))
        for fc in [self.fc1, self.fc2, self.fc3]:
            loss += #### 問①-1 ####
        return loss

    def backward(self):
        '''
        逆伝播
        '''
        # 勾配を逆伝播
        d = self.criterion.backward()
        d = self.fc3.backward(d)
        d = self.dropout2.backward(d)
        d = self.relu2.backward(d)
        d = self.fc2.backward(d)
        d = self.dropout1.backward(d)
        d = self.relu1.backward(d)
        d = self.fc1.backward(d)
        
        for fc in [self.fc1, self.fc2, self.fc3]:
            fc.dw += #### 問①-2 ####

    def optimize_GradientDecent(self, lr):
        '''
        勾配降下法による全層のパラメータの更新
        '''
        for fc in [self.fc1, self.fc2, self.fc3]:
            fc.w -= lr * fc.dw
            fc.b -= lr * fc.db

試したこと

下記のようなコードを試したのですが、うまくいきませんでした。

#### 問①-1 ####
loss += 0.5 * self.weight_decay_lambda * np.sum(lp_norm(FullyConnectedLayer[self.w]) ** 2)
#### 問①-2 ####
fc.dw += self.weight_decay_lambda * FullyConnectedLayer["fc"]