Batch Normalizationを実装できない

Question

![# 解決したい問題
3600個の画像データをミニバッチ処理するCNNを含んだニューラルネットワークの中の活性化関数の手前にBatch Normalizationを入れたいが、一個でも入れると　”ValueError: operands could not be broadcast together with shapes (50176,16) (12544,16) ”と　エラーが出てしまい実行できない。
該当する行列はmu(バッチ正規化する際の平均値）の行列

自分なりに考えたこと

バッチサイズが関係していることがバッチサイズだけ変えたときに上記の行列が変化するのでわかった。
データ数をバッチサイズで割り切れないため、最後のバッチのデータ数が足りなくなるのではないかと予想した。
なぜなら、上記の例では、データ数：3600、batch size:64でその商が56と1/4であり、12544は50176の1/4であるからだ。
しかし、バッチサイズをデータ数を割り切れる数字(例：100)に設定したところ、再び、”ValueError: operands could not be broadcast together with shapes (78400,16) (2822400,16) ”とエラーが出てしまい、何が原因なのか、わからなくなってしまいました。

該当コード

テキスト畳み込みニューラルネットワーク（ゼロから作るディープラーニング１のドロップアウトをバッチノーマライゼーションに変更）は文字数制約のため添付写真に表示

バッチノーマライゼーションのコード

class BatchNormalization:
    def __init__(self, gamma, beta, rho=0.9, moving_mean=None, moving_var=None):
        self.gamma = gamma # 学習によって更新させる.
        self.beta = beta #  学習によって更新させる
        self.rho = rho

        # 予測時に使用する平均と分散
        self.moving_mean = moving_mean   # muの移動平均
        self.moving_var = moving_var     # varの移動平均
        
        # 計算中に算出される値を保持しておく変数群
        self.batch_size = None
        self.x_mu = None
        self.x_std = None        
        self.std = None
        self.dgamma = None
        self.dbeta = None

    def forward(self, x, train_flg=True):
        """
        順伝播計算
        x :  CNNの場合は4次元、全結合層の場合は2次元  
        """
        if x.ndim == 4:
            """
            画像形式の場合
            """
            N, C, H, W = x.shape
            x = x.transpose(0, 2, 3, 1) # NHWCに入れ替え
            x = x.reshape(N*H*W, C) # (N*H*W,C)の2次元配列に変換
            out = self.__forward(x, train_flg)
            out = out.reshape(N, H, W, C)# 4次元配列に変換
            out = out.transpose(0, 3, 1, 2) # 軸をNCHWに入れ替え
        elif x.ndim == 2:
            """
            画像形式以外の場合
            """
            out = self.__forward(x, train_flg)           
            
        return out
            
    def __forward(self, x, train_flg, epsilon=1e-8):
        """
        x : 入力. N×Dの行列. Nはバッチサイズ. Dは手前の層のノード数
        """
        if (self.moving_mean is None) or (self.moving_var is None):
            N, D = x.shape
            self.moving_mean = np.zeros(D)
            self.moving_var = np.zeros(D)
                        
        if train_flg:
            """
            学習時
            """
            # 入力xについて、Nの方向に平均値を算出. 
            N, D = x.shape
            mu = np.mean(x, axis=0) # 要素数D個のベクトル
            mu = np.broadcast_to(mu, (N, D)) # Nの方向にブロードキャスト
            print("mu.shape=", mu.shape)
            
            # 入力xから平均値を引く
            x_mu = x - mu   # N×D行列
            print("x_mu.shape=", x_mu.shape)
            
            # 入力xの分散を求める
            var = np.mean(x_mu**2, axis=0)  # 要素数D個のベクトル
            print("var.shape=", var.shape)
            
            # 入力xの標準偏差を求める(epsilonを足してから標準偏差を求める)
            std = np.sqrt(var + epsilon)  # 要素数D個のベクトル
            print("std.shape=", std.shape)
            
            # 標準偏差の逆数を求める
            std_inv = 1 / std
            std_inv = np.broadcast_to(std_inv, (N, D)) # Nの方向にブロードキャスト
            print("std_inv.shape=", std_inv.shape)
            
            # 標準化
            x_std = x_mu * std_inv  #N*D行列
            print("x_std.shape=", x_std.shape)
                  
            # 値を保持しておく
            self.batch_size = x.shape[0]
            self.x_mu = x_mu
            self.x_std = x_std
            self.std = std
            self.moving_mean = self.rho * self.moving_mean + (1-self.rho) * mu
            self.moving_var = self.rho * self.moving_var + (1-self.rho) * var            
        else:
            """
            予測時
            """
            x_mu = x - self.moving_mean # N*D行列
            x_std = x_mu / np.sqrt(self.moving_var + epsilon) # N*D行列
            
        # gammaでスケールし、betaでシフトさせる
        out = self.gamma * x_std + self.beta # N*D行列
        return out

    def backward(self, dout):
        """
        逆伝播計算
        dout : CNNの場合は4次元、全結合層の場合は2次元  
        """
        if dout.ndim == 4:
            """
            画像形式の場合
            """            
            N, C, H, W = dout.shape
            dout = dout.transpose(0, 2, 3, 1) # NHWCに入れ替え
            dout = dout.reshape(N*H*W, C) # (N*H*W,C)の2次元配列に変換
            dx = self.__backward(dout)
            dx = dx.reshape(N, H, W, C)# 4次元配列に変換
            dx = dx.transpose(0, 3, 1, 2) # 軸をNCHWに入れ替え
        elif dout.ndim == 2:
            """
            画像形式以外の場合
            """
            dx = self.__backward(dout)

        return dx

    def __backward(self, dout):
        """
        ここを完成させるには、計算グラフを理解する必要があり、実装にかなり時間がかかる.
        """
        N, D = self.x_.shape
        
        # betaの勾配
        dbeta = np.sum(dout, axis=0)
        
        # gammaの勾配(Nの方向に合計)
        dgamma = np.sum(self.x_std * dout, axis=0)
        
        # Xstdの勾配
        a1 = self.gamma * dout
        print("a1.shape=", a1.shape)
        
        # Xmuの勾配(1つ目)
        a2 = a1 / self.std
        print("a2.shape=", a2.shape)
        
        # 標準偏差の逆数の勾配
        a3 = a1 * self.x_mu
        print("a3.shape=", a3.shape)
        a3 = np.sum(a3, axis=0) # Nの方向に合計
        
        # 標準偏差の勾配
        a4 = -(a3) / (self.std * self.std)
        print("a4.shape=", a4.shape)
        
        # 分散の勾配
        a5 = 0.5 * a4 / self.std
        print("a5.shape=", a5.shape)
        
        # Xmuの2乗の勾配
        a6 = a5 / self.batch_size
        a6 = np.broadcast_to(a6, (N, D)) # Nの方向にブロードキャスト
        print("a6=",a6)
        print("a6.shape=", a6.shape)
        
        # Xmuの勾配(2つ目)
        a7 = 2.0  * self.x_mu * a6
        print("a7.shape=", a7.shape)
        
        # muの勾配
        a8 = -(a2+a7)
        print("a8.shape=", a8.shape)
        a8 = np.sum(a8, axis=0) # Nの方向に合計

        # Xの勾配
        a9 = a8 / self.batch_size
        a9 = np.broadcast_to(a9, (N, D)) # Nの方向にブロードキャスト
        dx = a2 + a7 + a9
        print("a9.shape=", a9.shape)
        
        self.dgamma = dgamma
        self.dbeta = dbeta
        
        return dx

エラー文

~/Downloads/*****/畳み込み/common/layers.py in __forward(self, x, train_flg, epsilon)
371 self.x_std = x_std
372 self.std = std
--> 373 self.moving_mean = self.rho * self.moving_mean + (1-self.rho) * mu
374 self.moving_var = self.rho * self.moving_var + (1-self.rho) * var
375 else:

ValueError: operands could not be broadcast together with shapes (78400,16) (2822400,16) `

ご回答いただけたら、幸いです。](https://ddjkaamml8q8x.cloudfront.net/questions/2022-02-11/a99998cf-725f-4dac-8169-3cab12cdf9b5.png)

Comments

[ai_learner]

明記し忘れたのですが、ミニバッチ処理をしております。

[退会済みユーザー]

具体的なコードがないと回答が難しいのかもしれませんね。

直接的なエラーの原因は配列の形状が異なることによるもののようです。
https://numpy.org/doc/stable/user/basics.broadcasting.html

[ai_learner]

ご指摘いただきありがとうございます。
質問の方、編集させていただきました。
さらに必要なコードがありましたら、ご指摘いただきたいです。

[退会済みユーザー]

すみません、私も勉強中で、、全部の処理を追い切れていないのですが・・

> 『ゼロから作るDeep Learning』P.188
> ここでは、ミニバッチとして`B={x1,x2,...,xm}`というm個の入力データの集合に対して、平均`μB`、分散`σ^2B`を求めます。
> そして、入力データを平均が0で分散が1になるーー適切な分布になるーーように正規化します。

この式を見ますと、
`mu = np.broadcast_to(mu, (N, D)) # Nの方向にブロードキャスト`
のようなところで`N`の数に戻しているところが気になりました。

`__forward`メソッドの最初に`self.moving_mean = np.zeros(D)`してしますので、
`self.moving_mean`と`mu`は`D`の数の配列にしておく必要がありそうに感じました。

[ai_learner]

xg63ex2b様
お忙しい中、目を通していただきありがとうございます。
お恥ずかしながらご指摘いただいた self.moving_meanの配列とmuの配列が異なることを見落としていました。muはxから引く必要があるため、同じ形状（N,D）である必要があります。ですので、self.moving_meanの配列を self.moving_mean = np.zeros_like(x)を使い（N, D）に直しました。
これで、self.moving_meanとmuが同じ配列形状になったので理論上は計算できるはずです。
しかし、改訂後のモデルで実行した結果、同じようなエラー文が出てしまいました。
372 self.x_std = x_std
373 self.std = std
--> 374 self.moving_mean = self.rho * self.moving_mean + (1-self.rho) * mu
375 self.moving_var = self.rho * self.moving_var + (1-self.rho) * var
376 else:

ValueError: operands could not be broadcast together with shapes (200704,16) (100352,16)

回答いただきありがとうございました。

[退会済みユーザー]

> muはxから引く必要があるため、同じ形状（N,D）である必要があります。

この記載を見て、「ブロードキャスト」についての理解を深めると良さそうに思いました。

> ブロードキャストという用語は、NumPyが算術演算の際に異なる形状の配列をどのように扱うかを説明するものである。ある制約のもとで、小さい方の配列は大きい方の配列に「ブロードキャスト」され、両者の形状が一致するようになります。ブロードキャストは、配列の演算をベクトル化し、PythonではなくC言語でループが発生するようにするための手段です。これはデータの不要なコピーを作成することなく、通常、効率的なアルゴリズムの実装につながります。しかし、ブロードキャストは非効率的なメモリの使用を招き、計算を遅くするため、悪いアイデアである場合もあります。
> https://numpy.org/doc/stable/user/basics.broadcasting.html

ある制約のもとで、NumPyが両者の配列の形状を一致してくれるそうです。
次の画像のようなイメージになるそうです。

Broadcastable arrays
https://numpy.org/doc/stable/_images/broadcasting_2.png

次のコードでは、全ての行に対して列ごとに減算してみました。

```py
import numpy as np
a = np.array([[ 0.0, 0.0, 0.0],
[10.0, 10.0, 10.0],
[20.0, 20.0, 20.0],
[30.0, 30.0, 30.0]])
b = np.array([1.0, 2.0, 3.0])
a - b
# array([[-1., -2., -3.],
# [ 9., 8., 7.],
# [19., 18., 17.],
# [29., 28., 27.]])
```

[ai_learner]

xg63ex2b様
ご返信いただきありがとうございます。
numpyの配列同士の計算は、numpy.broadcast_toで明示的に変更しなくても、片方が同じで、片方が１ならば自動で調整してくれるのですね。スカラーでは経験的に知っていましたが、勉強不足でした。ご指摘いただき、ありがとうございます。最初にご教示いただいた方法で実行してみたのですが、自分のramのメモリ不足で”The kernel appears to have died. It will restart automatically.”と表示され、残念ながら実行できませんでした。以前はなかった現象なので、おそらく計算できたのだと思います。自分でいろいろ対応策を探して、改めて実行したいと思います。ありがとうございました。

[ai_learner]

macを再起動したところ、問題は解決し、ご教示いただいた改訂でBatch Normalizationが動くようになりました。　本当にありがとうございました。

Answer 1

修正依頼の欄にあるxg63ex2b様の方法により解決いたしました。