参照渡ししたはずのvectorがなくなっている.

前提・実現したいこと

うまく参照渡しをして関数を実行させたい.

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

* thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
    frame #0: 0x0000000100004dbb SIN`BPTT(RNN=0x00007ffeefbfeed8, data=size=1, t=4, Func="tanh") at RNNsin.cp:377
   374 	        for(j = 0; j < I_Unit; j++) {
   375 	            for(k = 0; k < M_Unit; k++) {
   376 	                for(l = 0; l < O_Unit; l++) {
-> 377 	                    ehNow[k][l] = (data[t*I_Unit + l] - RNN->o.n[l]) * RNN->m.v[k][l] * (1 - RNN->m.n[k] * RNN->m.n[k]);
   378 	                }
   379 	            }
   380 	        }

該当のソースコード

main関数は,
int main() {
vector<double> TS(TIME+1); //宣言
BPTT(&RNN, TS, t+T+1, Func); //関数の実行
}
といった感じの流れです.

c++
1void BPTT(ReccurentNeuralNetwork *RNN, const vector<double>& data, int t, string Func) {
2    int i, j, k, l;
3    vector< vector <double> > ehNow;
4    ehNow = vector< vector <double> >(M_Unit, vector <double> (O_Unit));
5    vector< vector < vector <double > > > ehPast;
6    ehPast = vector < vector < vector <double> > >(T, vector<vector<double> >(M_Unit, vector<double>(O_Unit, 0)));
7    double delta, g;
8
9    for(j = 0; j < I_Unit; j++) {
10        for(k = 0; k < M_Unit; k++) {
11            for(l = 0; l < O_Unit; l++) {
12                ehNow[k][l] = (data[t*I_Unit + l] - RNN->o.n[l]) * RNN->m.v[k][l] * (1 - RNN->m.n[k] * RNN->m.n[k]);
13            }
14        }
15    }
16    for(l = 0; l < O_Unit; l++) {
17        for(i = 0; i < T; i++) {
18            for(j = 0; j < M_Unit; j++) {
19                ehPast[i][j][l] = 0;
20                for(k = 0; k < M_Unit; k++) {
21                    if(i == 0)
22                        ehPast[i][j][l] += ehNow[k][l] * RNN->m.w[j][k] * (1 - RNN->pm[i].n[j] * RNN->pm[i].n[j]);
23                    else
24                        ehPast[i][j][l] += ehPast[i-1][k][l] * RNN->m.w[j][k] * (1 - RNN->pm[i].n[j] * RNN->pm[i].n[j]);
25                }
26            }
27        }
28    }
29   
30    //入力層の重みの更新ok
31    for(j = 0; j < I_Unit; j++) {
32        for(k = 0; k < M_Unit; k++) {
33            for(l = 0; l < O_Unit; l++) {
34                RNN->i.u[j][k] += eta * ehNow[k][l] * data[t*I_Unit + j];
35            }
36        }
37    }
38    for(i = 0; i < O_Unit; i++) {
39        for(j = 0; j < T; j++) {
40            for(k = 0; k < M_Unit; k++) {
41                for(l = 0; l < I_Unit; l++) {
42                    delta = ehPast[j][k][i];
43                    RNN->i.hu[l][k] += delta*delta;
44                    g = eta / sqrt(RNN->i.hu[l][k]);
45                    RNN->i.u[l][k] += g * delta * data[(t-T+j)*I_Unit + l];
46                }
47            }
48        }
49    }
50    //中間層のバイアスの更新
51    for(k = 0; k < M_Unit; k++) {
52        for(l = 0; l < O_Unit; l++) {
53            RNN->m.biasM[k] += eta * ehNow[k][l];
54        }
55    }
56    for(i = 0; i < O_Unit; i++) {
57        for(j = 0; j < T; j++) {
58            for(k = 0; k < M_Unit; k++) {
59                delta = ehPast[j][k][i];
60                RNN->m.hbiasM[k] += delta*delta;
61                g = eta / sqrt(RNN->m.hbiasM[k]);
62                RNN->m.biasM[k] += g * delta;
63            }
64        }
65    }
66    //中間層の重みの更新ok
67    for(i = 0; i < M_Unit; i++) {
68        for(j = 0; j < O_Unit; j++) {
69            RNN->m.hv[i][j] += (data[t*I_Unit + j] - RNN->o.n[j]) *  RNN->m.n[i] * (data[t*I_Unit + j] - RNN->o.n[j]) *  RNN->m.n[i];
70            RNN->m.v[i][j] += (eta * (data[t*I_Unit + j] - RNN->o.n[j]) * RNN->m.n[i]) / sqrt(RNN->m.hv[i][j]);
71        }
72    }
73    //フィードバック層の重みの更新ok
74    for(j = 0; j < M_Unit; j++) {
75        for(k = 0; k < M_Unit; k++) {
76            for(l = 0; l < O_Unit; l++) {
77                RNN->m.w[j][k] += eta * ehNow[k][l] * RNN->pm[0].n[j];
78            }
79        }
80    }
81    for(i = 0; i < O_Unit; i++) {
82        for(j = 0; j < T; j++) {
83            for(k = 0; k < M_Unit; k++) {
84                for(l = 0; l < M_Unit; l++) {
85                    delta = ehPast[j][k][i];
86                    RNN->m.hw[l][k] += delta*delta;
87                    g = eta / sqrt(RNN->m.hw[l][k]);
88                    RNN->m.w[l][k] += g * delta * RNN->pm[j+1].n[l];
89                }
90            }
91        }
92    }
93    //出力層のバイアスの更新ok
94    for(j = 0; j < O_Unit; j++) {
95        RNN->o.hbiasO[j] += (data[t*I_Unit + j] - RNN->o.n[j]) * (data[t*I_Unit + j] - RNN->o.n[j]);
96        RNN->o.biasO[j] += (eta * (data[t*I_Unit + j] - RNN->o.n[j])) / sqrt(RNN->o.hbiasO[j]);
97    }
98}