質問編集履歴
2
タイトルの変更
    
        title	
    CHANGED
    
    | @@ -1,1 +1,1 @@ | |
| 1 | 
            -
             | 
| 1 | 
            +
            ニューラルネットワークに内の内積計算エラーを解決したい
         | 
    
        body	
    CHANGED
    
    | 
            File without changes
         | 
1
該当コード、エラー内容を分かりやすくした
    
        title	
    CHANGED
    
    | 
            File without changes
         | 
    
        body	
    CHANGED
    
    | @@ -2,11 +2,12 @@ | |
| 2 2 | 
             
            ディープラーニングを用いて、道路の復旧期間日数の予測モデルを構築しています。
         | 
| 3 3 | 
             
            説明変数6種類(道路の崩壊程度、道路盛土の高さ、崩壊車線数など)、目的変数1種類(復旧までの日数)としてニュラールネットワークを構築しています。
         | 
| 4 4 |  | 
| 5 | 
            -
            そのなかで、以下のエラーメッセージが発生しました。
         | 
| 5 | 
            +
            そのなかで、以下の行列の内積計算エラーメッセージが発生しました。
         | 
| 6 6 |  | 
| 7 7 |  | 
| 8 | 
            -
             | 
| 8 | 
            +
            発生している問題・エラーメッセージ
         | 
| 9 9 | 
             
            ---------------------------------------------------------------------------
         | 
| 10 | 
            +
            ```python
         | 
| 10 11 | 
             
            ValueError                                Traceback (most recent call last)
         | 
| 11 12 | 
             
            <ipython-input-42-64c8b1648510> in <module>
         | 
| 12 13 | 
             
                  1 for i in range(epoch):
         | 
| @@ -29,123 +30,140 @@ | |
| 29 30 |  | 
| 30 31 | 
             
            ValueError: shapes (32,2) and (1,30) not aligned: 2 (dim 1) != 1 (dim 0)
         | 
| 31 32 |  | 
| 32 | 
            -
             | 
| 33 | 
            +
            ```
         | 
| 33 34 | 
             
            ### 該当のソースコード
         | 
| 35 | 
            +
            ```python
         | 
| 34 | 
            -
            import numpy as np | 
| 36 | 
            +
            import numpy as np
         | 
| 35 | 
            -
            import pandas as pd | 
| 37 | 
            +
            import pandas as pd
         | 
| 36 | 
            -
            from sklearn.model_selection import train_test_split | 
| 38 | 
            +
            from sklearn.model_selection import train_test_split
         | 
| 37 | 
            -
            import matplotlib.pyplot as plt | 
| 39 | 
            +
            import matplotlib.pyplot as plt
         | 
| 38 | 
            -
            import matplotlib.pyplot as plt | 
| 40 | 
            +
            import matplotlib.pyplot as plt
         | 
| 39 41 |  | 
| 42 | 
            +
            # affine変換してる
         | 
| 40 | 
            -
            def affine(z, w, b): | 
| 43 | 
            +
            def affine(z, w, b):
         | 
| 41 | 
            -
            return np.dot(z, w) + b | 
| 44 | 
            +
            return np.dot(z, w) + b
         | 
| 42 45 |  | 
| 46 | 
            +
            # affine変換勾配
         | 
| 47 | 
            +
            def affine_back(du, z, w, b):
         | 
| 48 | 
            +
            dz = np.dot(du, w.T)
         | 
| 49 | 
            +
            dw = np.dot(z.T, du)
         | 
| 50 | 
            +
            db = np.dot(np.ones(z.shape[0]).T, du)
         | 
| 51 | 
            +
            return dz, dw, db
         | 
| 52 | 
            +
            def sigmoid(u):
         | 
| 53 | 
            +
            return 1 / (1 + np.exp( u))
         | 
| 43 54 |  | 
| 44 | 
            -
            def affine_back(du, z, w, b): 
         | 
| 45 | 
            -
             | 
| 55 | 
            +
            #活性化関数 シグモイド の 勾配,中間層の勾配
         | 
| 46 | 
            -
            dw = np.dot(z.T, du) 
         | 
| 47 | 
            -
            db = np.dot(np.ones(z.shape[0]).T, du) 
         | 
| 48 | 
            -
            return dz, dw, db 
         | 
| 49 | 
            -
            def  | 
| 56 | 
            +
            def sigmoid_back(u):
         | 
| 50 | 
            -
            return  | 
| 57 | 
            +
            return (1 sigmoid(u)) * sigmoid(u)
         | 
| 58 | 
            +
            def identity(u):
         | 
| 59 | 
            +
            return u
         | 
| 51 60 |  | 
| 52 61 |  | 
| 62 | 
            +
            #二乗和誤差:回帰問題
         | 
| 53 | 
            -
            def  | 
| 63 | 
            +
            def squared_error(y, t):
         | 
| 54 | 
            -
            return  | 
| 64 | 
            +
            return 0.5 * np.sum((y t) ** 2) / y.shape[0]
         | 
| 55 | 
            -
            def identity(u): 
         | 
| 56 | 
            -
            return u 
         | 
| 57 65 |  | 
| 58 66 |  | 
| 67 | 
            +
            #誤差 二乗和誤差)+活性化関数 恒等関数 の勾配
         | 
| 68 | 
            +
            def identity_mean_s
         | 
| 59 | 
            -
             | 
| 69 | 
            +
            quared_error_back(y, t):
         | 
| 60 | 
            -
            return  | 
| 70 | 
            +
            return (y t) / y.shape[0]
         | 
| 61 71 |  | 
| 72 | 
            +
            #学習部分
         | 
| 73 | 
            +
            def learn(x, t, w1, b1, w2, b2, w3, b3, lr):
         | 
| 74 | 
            +
            #順伝播 入力データから、予測データを求めるまで
         | 
| 75 | 
            +
            u1 = affine(x, w1, b1)
         | 
| 76 | 
            +
            z1 = sigmoid(u1)
         | 
| 77 | 
            +
            u2 = affine(z1, w2, b2)
         | 
| 78 | 
            +
            z2 = sigmoid(u2)
         | 
| 79 | 
            +
            u3 = affine(z2, w3, b3)
         | 
| 80 | 
            +
            y = identity(u3)
         | 
| 62 81 |  | 
| 82 | 
            +
            #逆伝播 勾配の計算を求め、重みの更新を行う部分
         | 
| 63 | 
            -
             | 
| 83 | 
            +
            dy = identity_mean_squared_error_back(y, t)
         | 
| 84 | 
            +
            dz2, dw3, db3 = affine_back(dy, z2, w3, b3)
         | 
| 85 | 
            +
            du2 = sigmoid_back(u2)
         | 
| 86 | 
            +
            dz1, dw2, db2 = affine_back(du2, z1, w2, b2)
         | 
| 64 | 
            -
             | 
| 87 | 
            +
            du 1 = sigmoid_back(u1)
         | 
| 88 | 
            +
            dx, dw1, db1 = affine_back(du1, x, w1, b1)
         | 
| 65 89 |  | 
| 90 | 
            +
            #重み、バイアスの更新
         | 
| 91 | 
            +
            w1 = w1 lr * dw1
         | 
| 92 | 
            +
            b1 = b1 lr * db1
         | 
| 93 | 
            +
            w2 = w2 lr * dw2
         | 
| 94 | 
            +
            b2 = b2 lr * db2
         | 
| 95 | 
            +
            w3 = w3 lr * dw3
         | 
| 96 | 
            +
            b3 = b3 lr * db3
         | 
| 97 | 
            +
            return w1, b1, w2, b2, w3, b3
         | 
| 66 98 |  | 
| 67 | 
            -
            def  | 
| 99 | 
            +
            def predict(x, w1, b1, w2, b2, w3, b3):
         | 
| 100 | 
            +
            #順伝播
         | 
| 101 | 
            +
            u1 = affine(x, w1, b1)
         | 
| 102 | 
            +
            z1 = sigmoid(u1)
         | 
| 103 | 
            +
            u2 = affine(z1, w2, b2)
         | 
| 104 | 
            +
            z2 = sigmoid(u2)
         | 
| 105 | 
            +
            u3 = affine(z2, w3, b3)
         | 
| 106 | 
            +
            y = identity(u3)
         | 
| 107 | 
            +
            return y
         | 
| 68 108 |  | 
| 69 | 
            -
             | 
| 109 | 
            +
            #実行プログラム
         | 
| 70 | 
            -
             | 
| 110 | 
            +
            #地震データ読み込み
         | 
| 71 | 
            -
             | 
| 111 | 
            +
            df = pd.read_csv('earthquake_B_traffic.csv')
         | 
| 72 | 
            -
            z2 = sigmoid(u2) 
         | 
| 73 | 
            -
            u3 = affine(z2, w3, b3) 
         | 
| 74 | 
            -
            y = identity(u3) 
         | 
| 75 112 |  | 
| 113 | 
            +
            # データの作成データの作成 説明変数・目的変数分ける説明変数・目的変数分ける
         | 
| 114 | 
            +
            df_x = df.drop("regulatory period", axis=1)
         | 
| 115 | 
            +
            p= df.drop("damage range", axis=1)
         | 
| 116 | 
            +
            q= p.drop( "embankment height", axis=1)
         | 
| 117 | 
            +
            r= q.drop("landform", axis=1)
         | 
| 118 | 
            +
            s= r.drop("banking structure", axis=1)
         | 
| 119 | 
            +
            t= s.drop("damage form", axis=1)
         | 
| 120 | 
            +
            u= t.drop("traffic", axis=1)
         | 
| 76 121 |  | 
| 77 | 
            -
            dy = identity_mean_squared_error_back(y, t) 
         | 
| 78 | 
            -
            dz2, dw3, db3 = affine_back(dy, z2, w3, b3) 
         | 
| 79 | 
            -
            du2 = sigmoid_back(u2) 
         | 
| 80 | 
            -
             | 
| 122 | 
            +
            # 説明変数・目的変数をそれぞれ訓練データ・テストデータに分割説明変数・目的変数をそれぞれ訓練データ・テストデータに分割
         | 
| 81 | 
            -
            du1 = sigmoid_back(u1) 
         | 
| 82 | 
            -
             | 
| 123 | 
            +
            x_train, x_test, t_train, t_test = train_test_split(df_x, t, test_size=0.3)
         | 
| 83 124 |  | 
| 125 | 
            +
            #ノード数設定
         | 
| 126 | 
            +
            d0 = x_train.shape[1]
         | 
| 127 | 
            +
            d1 = 30 # 1層目のノード 数
         | 
| 128 | 
            +
            d2 = 30 # 2層目のノード数
         | 
| 129 | 
            +
            d3 = 1 #出力層
         | 
| 84 130 |  | 
| 85 | 
            -
             | 
| 131 | 
            +
            #重みの初期化 0.1 0.1 の乱数
         | 
| 132 | 
            +
            np.random.seed(8)
         | 
| 86 | 
            -
             | 
| 133 | 
            +
            w1 = np.random.rand(d0, d1)*0.001
         | 
| 87 | 
            -
            w2 =  | 
| 134 | 
            +
            w2 = np.random.rand(d1, d2)*0.001
         | 
| 88 | 
            -
            b2 = b2 - lr * db2 
         | 
| 89 | 
            -
            w3 = w3 - lr * dw3 
         | 
| 90 | 
            -
            b3 = b3 - lr * db3 
         | 
| 91 | 
            -
             | 
| 135 | 
            +
            w3 = np.random.rand(d2, d3)*0.001
         | 
| 92 | 
            -
             | 
| 136 | 
            +
            #重みを1 ~0.001 に設定する部分
         | 
| 93 137 |  | 
| 94 138 |  | 
| 95 | 
            -
             | 
| 139 | 
            +
            #バイアスの初期化 (
         | 
| 96 | 
            -
             | 
| 140 | 
            +
            b1 = np.zeros(d1)
         | 
| 97 | 
            -
            u2 = affine(z1, w2, b2) 
         | 
| 98 | 
            -
             | 
| 141 | 
            +
            b2 = np.zeros(d2)
         | 
| 99 | 
            -
            u3 = affine(z2, w3, b3) 
         | 
| 100 | 
            -
            y = identity(u3) 
         | 
| 101 | 
            -
             | 
| 142 | 
            +
            b3 = np.z
         | 
| 143 | 
            +
            eros(d3)
         | 
| 102 144 |  | 
| 145 | 
            +
            #学習率
         | 
| 103 | 
            -
             | 
| 146 | 
            +
            lr = 0.5
         | 
| 104 147 |  | 
| 148 | 
            +
            #バッチサイズ
         | 
| 149 | 
            +
            batch_size = 32
         | 
| 105 150 |  | 
| 106 | 
            -
            df_x = df.drop("regulatory period", axis=1) 
         | 
| 107 | 
            -
            p= df.drop("damage range", axis=1) 
         | 
| 108 | 
            -
            q= p.drop( "embankment height", axis=1) 
         | 
| 109 | 
            -
             | 
| 151 | 
            +
            #学習回数
         | 
| 110 | 
            -
            s= r.drop("banking structure", axis=1) 
         | 
| 111 | 
            -
            t= s.drop("damage form", axis=1) 
         | 
| 112 | 
            -
             | 
| 152 | 
            +
            epoch =1000
         | 
| 113 153 |  | 
| 154 | 
            +
            #グラフを 描写リスト
         | 
| 155 | 
            +
            x = [0, epoch]
         | 
| 156 | 
            +
            y = [0.100]
         | 
| 114 157 |  | 
| 158 | 
            +
            for i in range(epoch):
         | 
| 159 | 
            +
            for j in range(0, x_train.shape[0], batch_size): w1, b1, w2, b2, w3, b3 = learn(x_train[j:j + batch_size], t_train[j:j + batch_size], w1, b1, w2, b2, w3, b3,
         | 
| 115 | 
            -
             | 
| 160 | 
            +
            # 学習 shape[ 00 は行の大きさを調べている.ここでは, 77 .よって 0~77 の範囲でバッチサイズ文のステップ幅で数列を作成
         | 
| 116 161 |  | 
| 162 | 
            +
            ```
         | 
| 117 163 |  | 
| 118 | 
            -
            d0 = x_train.shape[1] 
         | 
| 119 | 
            -
            d1 = 30 # 1 層目のノード数 
         | 
| 120 | 
            -
            d2 = 30 # 2 層目のノード数 
         | 
| 121 | 
            -
            d3 = 1 #出力層 
         | 
| 122 164 |  | 
| 123 | 
            -
            w1 = np.random.rand(d0, d1)*0.001 
         | 
| 124 | 
            -
            w2 = np.random.rand(d1, d2)*0.001 
         | 
| 125 | 
            -
            w3 = np.random.rand(d2, d3)*0.001 
         | 
| 126 165 |  | 
| 127 166 |  | 
| 128 | 
            -
            b1 = np.zeros(d1) 
         | 
| 129 | 
            -
            b2 = np.zeros(d2) 
         | 
| 130 | 
            -
            b3 = np.zeros(d3) 
         | 
| 131 | 
            -
             | 
| 132 | 
            -
             | 
| 133 | 
            -
            lr = 0.5 
         | 
| 134 | 
            -
             | 
| 135 | 
            -
            batch_size = 32 
         | 
| 136 | 
            -
             | 
| 137 | 
            -
            epoch =1000 
         | 
| 138 | 
            -
             | 
| 139 | 
            -
            x = [0, epoch] 
         | 
| 140 | 
            -
            y = [0.100] 
         | 
| 141 | 
            -
             | 
| 142 | 
            -
            for i in range(epoch): 
         | 
| 143 | 
            -
            for j in range(0, x_train.shape[0], batch_size): w1, b1, w2, b2, w3, b3 = learn(x_train[j:j 
         | 
| 144 | 
            -
            + batch_size], t_train[j:j + batch_size], w1, b1, w2, b2, w3, b3, lr) 
         | 
| 145 | 
            -
             | 
| 146 | 
            -
             | 
| 147 | 
            -
             | 
| 148 | 
            -
             | 
| 149 167 | 
             
            ### 試したこと
         | 
| 150 168 | 
             
            説明変数の数を6種類から5種類に減らした結果、エラーの発生はなくプログラムが動きました。
         | 
| 151 169 | 
             
            ディープラーニングを用いた文字認識のモデルのこーどを参考にしています。
         | 
