編集履歴

質問編集履歴

質問の内容をよりピンポイントにしました.

2021/04/25 14:50

投稿

スコア6

test CHANGED Viewed

	@@ -1 +1 @@
1	- Tensorflow~~で, 定義したC~~ellにおいて~~前時刻の隠れ層の入力を取得する方法~~
1	+ Tensorflowのlayerのcall関数について

test CHANGED Viewed

@@ -1,457 +1,9 @@
 ### 概要
-　現在, Tensorflowを用いて時系列データの予測を行うCTRNN(Continuous-time RNN)の実装を行なっております.
+　現在, Tensorflowを用いて時系列データの予測を行うRNNの実装を行なっております.
-　CTRNNでの入力層から隠れ層における順伝播計算は以下のようになっており, 隠れ層の前時刻の入力u_t-1を必要とします.
-u_{t,i} = (1 - 1/τ)u_{t-1,i} + 1/τ{(Σw*x_t) + (Σw*c_{t-1}) +b}
+[Webサイト](https://qiita.com/everylittle/items/c088564d53cdfcde92cc)と, [Tensorflowのライブラリ](https://github.com/tensorflow/tensorflow/blob/v2.1.0/tensorflow/python/keras/layers/recurrent.py)の主にAbstractRNNCell, SimpleRNNCELL, LSTMCellの部分を参考にしているのですが, LSTMCellのcall関数において, h, [h,c]を返しているのはどういう意味なのでしょうか?
-c_{t,i} = activation(u_{t,i})  (wは重み, bはバイアス, τは時定数)
-[Webサイト](https://qiita.com/everylittle/items/c088564d53cdfcde92cc)と, [Tensorflowのライブラリ](https://github.com/tensorflow/tensorflow/blob/v2.1.0/tensorflow/python/keras/layers/recurrent.py)の主にAbstractRNNCell, SimpleRNNCELL, LSTMCellの部分を参考に, 自分でCTRNNCellを定義したのですが, コード中にあるstatesにu_{t-1}を含め, それを取得する方法がわかりません.
-申し訳ありませんが, アドバイスやご回答いただければ幸いです.
-また, 質問で不足している事項がありましたら, ご指摘ください. よろしくお願いします.
-```Python3
-import tensorflow as tf
-import numpy as np
-import math###
-from tensorflow.keras import Sequential
-from tensorflow.keras.layers import RNN, AbstractRNNCell
-from tensorflow.keras.optimizers import SGD
-from tensorflow.keras import layers
-from tensorflow.python.keras import activations, constraints, initializers, regularizers
-from tensorflow.python.keras import backend as K
-from tensorflow.python.keras.utils import tf_utils
-from tensorflow.python.ops import array_ops
-import matplotlib.pyplot as plt
-class CTRNNCell(AbstractRNNCell):
-  def __init__(self,
-               units,
-               activation='tanh',
-               use_bias=True,
-               kernel_initializer='glorot_uniform',
-               recurrent_initializer='orthogonal',
-               bias_initializer='zeros',
-               kernel_regularizer=None,
-               recurrent_regularizer=None,
-               bias_regularizer=None,
-               kernel_constraint=None,
-               recurrent_constraint=None,
-               bias_constraint=None,
-               tau=3,
-               **kwargs):
-    super(CTRNNCell, self).__init__(**kwargs)
-    self.units = units
-    self.activation = activations.get(activation)
-    self.use_bias = use_bias
-    self.kernel_initializer = initializers.get(kernel_initializer)
-    self.recurrent_initializer = initializers.get(recurrent_initializer)
-    self.bias_initializer = initializers.get(bias_initializer)
-    self.kernel_regularizer = regularizers.get(kernel_regularizer)
-    self.recurrent_regularizer = regularizers.get(recurrent_regularizer)
-    self.bias_regularizer = regularizers.get(bias_regularizer)
-    self.kernel_constraint = constraints.get(kernel_constraint)
-    self.recurrent_constraint = constraints.get(recurrent_constraint)
-    self.bias_constraint = constraints.get(bias_constraint)
-    self.tau = tau
-  @property
-  def state_size(self):
-    return self.units
-  def build(self, input_shape):
-    input_dim = input_shape[-1]
-    self.kernel = self.add_weight(
-        shape=(input_dim, self.units),
-        name='kernel',
-        initializer=self.kernel_initializer,
-        regularizer=self.kernel_regularizer,
-        constraint=self.kernel_constraint)
-    self.recurrent_kernel = self.add_weight(
-        shape=(self.units,self.units),
-        name='recurrent_kernel',
-        initializer=self.recurrent_initializer,
-        regularizer=self.recurrent_regularizer,
-        constraint=self.recurrent_constraint)
-    if self.use_bias:
-      self.bias = self.add_weight(
-          shape=(self.units,),
-          name='bias',
-          initializer=self.bias_initializer,
-          regularizer=self.bias_regularizer,
-          constraint=self.bias_constraint)
-    else:
-      self.bias = None
-    self.built = True
-  def call(self, inputs, states, training=None):
-    #前時刻のuを取得する方法がわからない
-    prev_c = states[0]  # previous memory state
-    #prev_u = states[0]
-    prev_u = states[1]
-    u = K.dot(inputs, self.kernel)
-    if self.use_bias:
-      u = K.bias_add(u, self.bias)
-    u = (1-1/self.tau)*prev_u + 1/self.tau*u +1/self.tau*K.dot(prev_c, self.recurrent_kernel)
-    #print(u)
-    c = self.activation(u)
-    return c, c
-#シードを固定
-def set_seed(seed=12345):
-    np.random.seed(seed)
-    tf.random.set_seed(seed)
-#データ取得
-def get_training_data():
-    period = 50
-    time_steps = np.arange(5*period)
-    data = [np.cos((2*np.pi*time_steps/period)),
-            np.sin((2*2*np.pi*time_steps/period))]
-    data = np.array(data).T
-    noise = np.random.normal(0, 0.01, data.shape)
-    data = data + noise
-    #(1, datalen, dim)に配列をreshape
-    data = data[np.newaxis, :, :]
-    return data
-def get_input_target(data):
-    input_data = data[:, :-1, :]
-    target_data = data[:, 1:, :]
-    return input_data, target_data
-def build_model(data_length, in_state_size, hidden_state_size, out_state_size,
-                train=False):
-    inputs = tf.keras.Input(shape=(data_length, in_state_size))
-    initial_hidden_input = tf.keras.Input(shape=(hidden_state_size,))
-    hidden_states, hidden_state = RNN(CTRNNCell(hidden_state_size),
-                                      return_sequences=True, return_state=True)(
-            inputs, initial_state=[initial_hidden_input])
-    outputs = layers.Dense(out_state_size, activation="tanh")(hidden_states)
-    if train:#訓練用
-        model = tf.keras.Model(inputs=[inputs, initial_hidden_input],
-                               outputs=outputs)
-    else:#予測用
-        model = tf.keras.Model(inputs=[inputs, initial_hidden_input],
-                               outputs=[outputs, hidden_state])
-    return model
-def plot(target_data, open_outputs, closed_outputs):
-    fig = plt.figure(figsize=(12, 4))
-    ax = plt.subplot2grid((1, 3), (0, 0))
-    ax.set_title("Target")
-    ax.set_aspect("equal")
-    ax.grid(True)
-    ax.set_xlim([-1.2, 1.2])
-    ax.set_ylim([-1.2, 1.2])
-    ax.plot(target_data[0, :, 0], target_data[0, :, 1])
-    ax = plt.subplot2grid((1, 3), (0, 1))
-    ax.set_title("Open-loop generation")
-    ax.set_aspect("equal")
-    ax.grid(True)
-    ax.set_xlim([-1.2, 1.2])
-    ax.set_ylim([-1.2, 1.2])
-    ax.plot(open_outputs[0, :, 0], open_outputs[0, :, 1])
-    ax = plt.subplot2grid((1, 3), (0, 2))
-    ax.set_title("Closed-loop generation")
-    ax.set_aspect("equal")
-    ax.grid(True)
-    ax.set_xlim([-1.2, 1.2])
-    ax.set_ylim([-1.2, 1.2])
-    ax.plot(closed_outputs[0, :, 0], closed_outputs[0, :, 1])
-    plt.tight_layout()
-    plt.show()
-def main():
-    set_seed()
-    data = get_training_data()
-    input_data, target_data = get_input_target(data)
-    data_length = input_data.shape[1]
-    in_state_size = input_data.shape[2]
-    hidden_state_size = 20
-    out_state_size = target_data.shape[2]
-    model = build_model(data_length, in_state_size, hidden_state_size,
-                        out_state_size, train=True)
-    model.summary()
-    optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)
-    model.compile(optimizer, loss="mse")
-    hidden_state = np.zeros([1, hidden_state_size])
-    model.fit([input_data, hidden_state], target_data, epochs=1000, verbose=0)
-    open_outputs = model.predict([input_data, hidden_state])
-    model_test = build_model(1, in_state_size, hidden_state_size,
-                             out_state_size, train=False)
-    model_test.set_weights(model.get_weights())
-    model_test.summary()
-    predicted_input = input_data[:, :1, :] # used as an initial input
-    hidden_state = np.zeros([1, hidden_state_size]) # used as an initial hidden state
-    generation_length=data_length
-    closed_outputs=np.zeros([1, generation_length, out_state_size])
-    for time_step in range(generation_length):
-        predicted_input, hidden_state = model_test.predict(
-            [predicted_input, hidden_state])
-        closed_outputs[0, time_step, :] = predicted_input[0, 0, :]
-    plot(target_data, open_outputs, closed_outputs)
-if __name__  == "__main__":
-    main()
-```
+[h, c]であれば納得感があるのですが...