ホーム » TensorFlow 2.0 » TensorFlow 2.0 : 上級 Tutorials : 構造化データ :- 時系列予報

TensorFlow 2.0 : 上級 Tutorials : 構造化データ :- 時系列予報

TensorFlow 2.0 : 上級 Tutorials : 構造化データ :- 時系列予報 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 11/20/2019

* 本ページは、TensorFlow org サイトの TF 2.0 – Advanced Tutorials – Structured data の以下のページを翻訳した上で
適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com ; WebSite: https://www.classcat.com/
Facebook: https://www.facebook.com/ClassCatJP/

 

構造化データ :- 時系列予報

このチュートリアルはリカレント・ニューラルネットワーク (RNN) を使用する時系列予報 (= forecasting) へのイントロダクションです。これは 2 つのパートでカバーされます : 最初に、単量時系列を予報して、それから多変量時系列を予報します。

from __future__ import absolute_import, division, print_function, unicode_literals
import tensorflow as tf

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import os
import pandas as pd

mpl.rcParams['figure.figsize'] = (8, 6)
mpl.rcParams['axes.grid'] = False

 

天気データセット

このチュートリアルは Max-Planck-Institute for Biogeochemistry (生物地球化学) により記録された 天気時系列データセット を使用します。

このデータセットは、気温、気圧と湿度のような 14 の異なる特徴を含みます。これらは 2003 年に始まり、10 分毎に収集されました。効率のために、2009 と 2016 の間に収集されたデータだけを使用します。データセットのこのセクションは François Chollet により彼の書籍 Deep Learning with Python のために準備されました。

zip_path = tf.keras.utils.get_file(
    origin='https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip',
    fname='jena_climate_2009_2016.csv.zip',
    extract=True)
csv_path, _ = os.path.splitext(zip_path)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip
13574144/13568290 [==============================] - 0s 0us/step
df = pd.read_csv(csv_path)

データを少し見てみましょう。

df.head()

Date Time p (mbar) T (degC) Tpot (K) Tdew (degC) rh (%) VPmax (mbar) VPact (mbar) VPdef (mbar) sh (g/kg) H2OC (mmol/mol) rho (g/m**3) wv (m/s) max. wv (m/s) wd (deg)
0 01.01.2009 00:10:00 996.52 -8.02 265.40 -8.90 93.3 3.33 3.11 0.22 1.94 3.12 1307.75 1.03 1.75 152.3
1 01.01.2009 00:20:00 996.57 -8.41 265.01 -9.28 93.4 3.23 3.02 0.21 1.89 3.03 1309.80 0.72 1.50 136.1
2 01.01.2009 00:30:00 996.53 -8.51 264.91 -9.31 93.9 3.21 3.01 0.20 1.88 3.02 1310.24 0.19 0.63 171.6
3 01.01.2009 00:40:00 996.51 -8.31 265.12 -9.07 94.2 3.26 3.07 0.19 1.92 3.08 1309.19 0.34 0.50 198.0
4 01.01.2009 00:50:00 996.51 -8.27 265.15 -9.04 94.1 3.27 3.08 0.19 1.92 3.09 1309.00 0.32 0.63 214.3

上で見れるように、観測は 10 分毎に記録されます。これは、単一の時間 (= hour) について、6 観測を持つことを意味します。同様に、単一の日 (= day) は 144 (6×24) 観測を含みます。

特定の時間が与えられたとき、未来の 6 時間で気温を予測することを望むとしましょう。この予測を行なうために、観測の 5 日を使用することを選択します。こうして、モデルを訓練するために最後の 720(5×144) 観測を含むウィンドウを作成します。このデータセットを実験するために良いものにする、多くのそのような構成が可能です。

下の関数はその上で訓練するモデルのために上で説明された時間のウィンドウを返します。パラメータ history_size は情報の過去のウィンドウのサイズです。target_size は未来のどのくらい離れてモデルが予測することを学習する必要があるかです。target_size は予測される必要があるラベルです。

def univariate_data(dataset, start_index, end_index, history_size, target_size):
  data = []
  labels = []

  start_index = start_index + history_size
  if end_index is None:
    end_index = len(dataset) - target_size

  for i in range(start_index, end_index):
    indices = range(i-history_size, i)
    # Reshape data from (history_size,) to (history_size, 1)
    data.append(np.reshape(dataset[indices], (history_size, 1)))
    labels.append(dataset[i+target_size])
  return np.array(data), np.array(labels)

次のチュートリアルの両者で、データの最初の 300,000 行は訓練データセットで、残りの検証データセットがあります。これは訓練データの ~2100 日分になります。

TRAIN_SPLIT = 300000

再現性を保証するために seed を設定します。

tf.random.set_seed(13)

 

パート 1 : 単変量時系列を予報する

最初に、単一の特徴 (temperature) だけを使用してモデルを訓練し、そしてそれを未来のその値のための予測を行なうために使用します。

最初にデータセットから temperature だけを抽出しましょう。

uni_data = df['T (degC)']
uni_data.index = df['Date Time']
uni_data.head()
Date Time
01.01.2009 00:10:00   -8.02
01.01.2009 00:20:00   -8.41
01.01.2009 00:30:00   -8.51
01.01.2009 00:40:00   -8.31
01.01.2009 00:50:00   -8.27
Name: T (degC), dtype: float64

このデータが時間に渡りどのように見えるか観察しましょう。

uni_data.plot(subplots=True)
array([],
      dtype=object)

uni_data = uni_data.values

ニューラルネットワークを訓練する前に特徴を正規化することは重要です。それを行なう一般的な方法は各特徴の平均を引いてそして標準偏差で除算することです。

Note: 平均と標準偏差は訓練データだけを使用して計算されるべきです。

uni_train_mean = uni_data[:TRAIN_SPLIT].mean()
uni_train_std = uni_data[:TRAIN_SPLIT].std()

データを正規化しましょう。

uni_data = (uni_data-uni_train_mean)/uni_train_std

今は単変量モデルのためのデータを作成しましょう。パート 1 については、モデルは最後の 20 の記録された気温観測が与えられて、そして次の時間ステップでの気温を予測することを学習する必要があります。

univariate_past_history = 20
univariate_future_target = 0

x_train_uni, y_train_uni = univariate_data(uni_data, 0, TRAIN_SPLIT,
                                           univariate_past_history,
                                           univariate_future_target)
x_val_uni, y_val_uni = univariate_data(uni_data, TRAIN_SPLIT, None,
                                       univariate_past_history,
                                       univariate_future_target)

これが univariate_data 関数が返すものです。

print ('Single window of past history')
print (x_train_uni[0])
print ('\n Target temperature to predict')
print (y_train_uni[0])
Single window of past history
[[-1.99766294]
 [-2.04281897]
 [-2.05439744]
 [-2.0312405 ]
 [-2.02660912]
 [-2.00113649]
 [-1.95134907]
 [-1.95134907]
 [-1.98492663]
 [-2.04513467]
 [-2.08334362]
 [-2.09723778]
 [-2.09376424]
 [-2.09144854]
 [-2.07176515]
 [-2.07176515]
 [-2.07639653]
 [-2.08913285]
 [-2.09260639]
 [-2.10418486]]

 Target temperature to predict
-2.1041848598100876

データが作成された今、単一のサンプルを見てみましょう。ネットワークに与えられる情報は青色で与えられ、そしてそれは赤い × 印の値を予測しなければなりません。

def create_time_steps(length):
  time_steps = []
  for i in range(-length, 0, 1):
    time_steps.append(i)
  return time_steps
def show_plot(plot_data, delta, title):
  labels = ['History', 'True Future', 'Model Prediction']
  marker = ['.-', 'rx', 'go']
  time_steps = create_time_steps(plot_data[0].shape[0])
  if delta:
    future = delta
  else:
    future = 0

  plt.title(title)
  for i, x in enumerate(plot_data):
    if i:
      plt.plot(future, plot_data[i], marker[i], markersize=10,
               label=labels[i])
    else:
      plt.plot(time_steps, plot_data[i].flatten(), marker[i], label=labels[i])
  plt.legend()
  plt.xlim([time_steps[0], (future+5)*2])
  plt.xlabel('Time-Step')
  return plt
show_plot([x_train_uni[0], y_train_uni[0]], 0, 'Sample Example')
<module 'matplotlib.pyplot' from '/home/kbuilder/.local/lib/python3.6/site-packages/matplotlib/pyplot.py'>

 

ベースライン

モデルを訓練することに進む前に、最初に単純なベースラインを設定しましょう。入力ポイントが与えられたとき、baseline メソッドは総ての履歴を見てそして次のポイントを最後の 20 観測の平均として予測します。

def baseline(history):
  return np.mean(history)
show_plot([x_train_uni[0], y_train_uni[0], baseline(x_train_uni[0])], 0,
           'Baseline Prediction Example')
<module 'matplotlib.pyplot' from '/home/kbuilder/.local/lib/python3.6/site-packages/matplotlib/pyplot.py'>

リカレント・ニューラルネットワークを使用してこのベースラインに打ち勝てるか見ましょう。

 

リカレント・ニューラルネットワーク

リカレント・ニューラルネットワーク (RNN) は時系列データに適切なニューラルネットワークのタイプです。RNN は、そこまでに見た情報を要約した内部状態を保持しながら、時系列をステップ毎に処理します。より詳細については、RNN チュートリアル を読んでください。このチュートリアルでは、Long Short Term Memory (LSTM) と呼ばれる特殊な RNN 層を使用します。

今はデータセットを shuffle, batch と cache するために tf.data を使用しましょう。

BATCH_SIZE = 256
BUFFER_SIZE = 10000

train_univariate = tf.data.Dataset.from_tensor_slices((x_train_uni, y_train_uni))
train_univariate = train_univariate.cache().shuffle(BUFFER_SIZE).batch(BATCH_SIZE).repeat()

val_univariate = tf.data.Dataset.from_tensor_slices((x_val_uni, y_val_uni))
val_univariate = val_univariate.batch(BATCH_SIZE).repeat()

次の可視化はデータがバッチ化の後でどのように表わされるかを理解する助けになるはずです。

LSTM はそれが与えられるデータの入力 shape を要求することを見るでしょう。

simple_lstm_model = tf.keras.models.Sequential([
    tf.keras.layers.LSTM(8, input_shape=x_train_uni.shape[-2:]),
    tf.keras.layers.Dense(1)
])

simple_lstm_model.compile(optimizer='adam', loss='mae')

モデルの出力を確認するために、サンプル予測を作成しましょう。

for x, y in val_univariate.take(1):
    print(simple_lstm_model.predict(x).shape)
(256, 1)

今はモデルを訓練しましょう。巨大なサイズのデータセットであるため、時間を節約するために、通常成されるような完全な訓練データの代わりに、各エポックは 200 ステップの間だけ実行します。

EVALUATION_INTERVAL = 200
EPOCHS = 10

simple_lstm_model.fit(train_univariate, epochs=EPOCHS,
                      steps_per_epoch=EVALUATION_INTERVAL,
                      validation_data=val_univariate, validation_steps=50)
Train for 200 steps, validate for 50 steps
Epoch 1/10
200/200 [==============================] - 3s 16ms/step - loss: 0.4075 - val_loss: 0.1351
Epoch 2/10
200/200 [==============================] - 1s 5ms/step - loss: 0.1118 - val_loss: 0.0360
Epoch 3/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0490 - val_loss: 0.0289
Epoch 4/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0444 - val_loss: 0.0257
Epoch 5/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0299 - val_loss: 0.0235
Epoch 6/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0317 - val_loss: 0.0223
Epoch 7/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0287 - val_loss: 0.0206
Epoch 8/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0263 - val_loss: 0.0196
Epoch 9/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0254 - val_loss: 0.0182
Epoch 10/10
200/200 [==============================] - 1s 5ms/step - loss: 0.0227 - val_loss: 0.0173

<tensorflow.python.keras.callbacks.History at 0x7fc322e8b908>

 
単純な LSTM モデルを使用して予測する

単純な LSTM を訓練した今、試して 2, 3 の予測を行なってみましょう。

for x, y in val_univariate.take(3):
  plot = show_plot([x[0].numpy(), y[0].numpy(),
                    simple_lstm_model.predict(x)[0]], 0, 'Simple LSTM model')
  plot.show()

これはベースラインよりも良いようです。基本を見た今、パート 2 に移りましょう、そこでは多変量時系列で作業します。

 

パート 2 : 多変量時系列を予報する

元のデータセットは 14 の特徴を含みます。単純化のために、このセクションは元の 14 の 3 つだけを考えます。使用される特徴は気温 (= air temperature)、気圧 (= atmospheric pressure) と空気密度 (= air density) です。

より多くの特徴を使用するには、このリストにそれらの名前を追加します。

features_considered = ['p (mbar)', 'T (degC)', 'rho (g/m**3)']
features = df[features_considered]
features.index = df['Date Time']
features.head()

p (mbar) T (degC) rho (g/m**3)
Date Time
01.01.2009 00:10:00 996.52 -8.02 1307.75
01.01.2009 00:20:00 996.57 -8.41 1309.80
01.01.2009 00:30:00 996.53 -8.51 1310.24
01.01.2009 00:40:00 996.51 -8.31 1309.19
01.01.2009 00:50:00 996.51 -8.27 1309.00

これらの特徴の各々が時間に渡りどのように変換するか見てみましょう。

features.plot(subplots=True)
array([,
       ,
       ],
      dtype=object)

言及されたように、最初のステップは訓練データの平均と標準偏差を使用してデータセットを正規化することです。

dataset = features.values
data_mean = dataset[:TRAIN_SPLIT].mean(axis=0)
data_std = dataset[:TRAIN_SPLIT].std(axis=0)

dataset = (dataset-data_mean)/data_std

 

シングルステップ・モデル

シングルステップ・セットアップでは、モデルは提供される幾つかの履歴をもとに未来の単一ポイントを予測することを学習します。

下の関数は下と (訳注: 原文ママ) 同じ windowing タスクを遂行しますが、けれども、ここではそれは与えられたステップサイズに基づいて過去の観測をサンプリングします。

def multivariate_data(dataset, target, start_index, end_index, history_size,
                      target_size, step, single_step=False):
  data = []
  labels = []

  start_index = start_index + history_size
  if end_index is None:
    end_index = len(dataset) - target_size

  for i in range(start_index, end_index):
    indices = range(i-history_size, i, step)
    data.append(dataset[indices])

    if single_step:
      labels.append(target[i+target_size])
    else:
      labels.append(target[i:i+target_size])

  return np.array(data), np.array(labels)

このチュートリアルでは、ネットワークは最後の 5 日間からデータを見せられます、i.e. 毎時サンプリングされる 720 観測です。サンプリングは 1 時間毎に行なわれます、何故ならば 60 分内に極端な変更は想定されないためです。こうして、120 観測が最後の 5 日間の履歴を表します。シングルステップ予測モデルについては、データポイントのためのラベルは未来に向けた気温 12 時間です。このためのラベルを作成するため、72(12*6) 観測後の気温が使用されます。

past_history = 720
future_target = 72
STEP = 6

x_train_single, y_train_single = multivariate_data(dataset, dataset[:, 1], 0,
                                                   TRAIN_SPLIT, past_history,
                                                   future_target, STEP,
                                                   single_step=True)
x_val_single, y_val_single = multivariate_data(dataset, dataset[:, 1],
                                               TRAIN_SPLIT, None, past_history,
                                               future_target, STEP,
                                               single_step=True)

単一データポイントを見ましょう。

print ('Single window of past history : {}'.format(x_train_single[0].shape))
Single window of past history : (120, 3)
train_data_single = tf.data.Dataset.from_tensor_slices((x_train_single, y_train_single))
train_data_single = train_data_single.cache().shuffle(BUFFER_SIZE).batch(BATCH_SIZE).repeat()

val_data_single = tf.data.Dataset.from_tensor_slices((x_val_single, y_val_single))
val_data_single = val_data_single.batch(BATCH_SIZE).repeat()
single_step_model = tf.keras.models.Sequential()
single_step_model.add(tf.keras.layers.LSTM(32,
                                           input_shape=x_train_single.shape[-2:]))
single_step_model.add(tf.keras.layers.Dense(1))

single_step_model.compile(optimizer=tf.keras.optimizers.RMSprop(), loss='mae')

サンプル予測を確認しましょう。

for x, y in val_data_single.take(1):
  print(single_step_model.predict(x).shape)
(256, 1)
single_step_history = single_step_model.fit(train_data_single, epochs=EPOCHS,
                                            steps_per_epoch=EVALUATION_INTERVAL,
                                            validation_data=val_data_single,
                                            validation_steps=50)
Train for 200 steps, validate for 50 steps
Epoch 1/10
200/200 [==============================] - 5s 25ms/step - loss: 0.3090 - val_loss: 0.2646
Epoch 2/10
200/200 [==============================] - 2s 11ms/step - loss: 0.2625 - val_loss: 0.2428
Epoch 3/10
200/200 [==============================] - 2s 11ms/step - loss: 0.2613 - val_loss: 0.2457
Epoch 4/10
200/200 [==============================] - 2s 11ms/step - loss: 0.2569 - val_loss: 0.2444
Epoch 5/10
200/200 [==============================] - 2s 11ms/step - loss: 0.2263 - val_loss: 0.2357
Epoch 6/10
200/200 [==============================] - 2s 11ms/step - loss: 0.2411 - val_loss: 0.2696
Epoch 7/10
200/200 [==============================] - 2s 10ms/step - loss: 0.2414 - val_loss: 0.2564
Epoch 8/10
200/200 [==============================] - 2s 10ms/step - loss: 0.2407 - val_loss: 0.2414
Epoch 9/10
200/200 [==============================] - 2s 10ms/step - loss: 0.2447 - val_loss: 0.2459
Epoch 10/10
200/200 [==============================] - 2s 10ms/step - loss: 0.2381 - val_loss: 0.2499
def plot_train_history(history, title):
  loss = history.history['loss']
  val_loss = history.history['val_loss']

  epochs = range(len(loss))

  plt.figure()

  plt.plot(epochs, loss, 'b', label='Training loss')
  plt.plot(epochs, val_loss, 'r', label='Validation loss')
  plt.title(title)
  plt.legend()

  plt.show()
plot_train_history(single_step_history,
                   'Single Step Training and validation loss')

 
シングルステップ未来を予測する

モデルが訓練された今、幾つかのサンプル予測を行ないましょう。モデルは (120 データポイントの) 毎時サンプリングされた過去 5 日間に渡る 3 つの特徴の履歴が与えられます、ゴールは気温を予測することですので、プロットは過去の気温を表示するだけです。予測は未来に向けて 1 日間行なわれます (履歴と予測の隔たりゆえに)。

for x, y in val_data_single.take(3):
  plot = show_plot([x[0][:, 1].numpy(), y[0].numpy(),
                    single_step_model.predict(x)[0]], 12,
                   'Single Step Prediction')
  plot.show()

 

マルチステップ・モデル

マルチステップ予測モデルでは、過去の履歴が与えられたとき、モデルは未来の値の範囲を予測することを学習する必要があります。こうして、単一の特徴ポイントだけが予測されるシングルステップ・モデルと違い、マルチステップ・モデルは未来のシークエンスを予測します。

マルチステップ・モデルについて、訓練データは再度毎時サンプリングされた過去 5 日間に渡る記録から成ります。けれども、ここでは、モデルは次の 12 時間について気温を予測することを学習する必要があります。観測は 10 分毎に取られますので、出力は 72 予測です。このタスクのために、データセットはそれに応じて準備される必要がありますので、最初のステップはそれを単に再度作成することですが、異なるターゲット・ウィンドウでです。

future_target = 72
x_train_multi, y_train_multi = multivariate_data(dataset, dataset[:, 1], 0,
                                                 TRAIN_SPLIT, past_history,
                                                 future_target, STEP)
x_val_multi, y_val_multi = multivariate_data(dataset, dataset[:, 1],
                                             TRAIN_SPLIT, None, past_history,
                                             future_target, STEP)

サンプル・データポイントを確認しましょう。

print ('Single window of past history : {}'.format(x_train_multi[0].shape))
print ('\n Target temperature to predict : {}'.format(y_train_multi[0].shape))
Single window of past history : (120, 3)

 Target temperature to predict : (72,)
train_data_multi = tf.data.Dataset.from_tensor_slices((x_train_multi, y_train_multi))
train_data_multi = train_data_multi.cache().shuffle(BUFFER_SIZE).batch(BATCH_SIZE).repeat()

val_data_multi = tf.data.Dataset.from_tensor_slices((x_val_multi, y_val_multi))
val_data_multi = val_data_multi.batch(BATCH_SIZE).repeat()

サンプル・データポイントをプロットする。

def multi_step_plot(history, true_future, prediction):
  plt.figure(figsize=(12, 6))
  num_in = create_time_steps(len(history))
  num_out = len(true_future)

  plt.plot(num_in, np.array(history[:, 1]), label='History')
  plt.plot(np.arange(num_out)/STEP, np.array(true_future), 'bo',
           label='True Future')
  if prediction.any():
    plt.plot(np.arange(num_out)/STEP, np.array(prediction), 'ro',
             label='Predicted Future')
  plt.legend(loc='upper left')
  plt.show()

このプロットと続く同様のプロットでは、履歴と未来データは毎時サンプリングされます。

for x, y in train_data_multi.take(1):
  multi_step_
plot(x[0], y[0], np.array([0]))

ここでのタスクは前のタスクよりも少しだけ複雑ですので、今はモデルは 2 つの LSTM 層から成ります。最後に、72 予測が行なわれますので、dense 層は 72 予測を出力します。

multi_step_model = tf.keras.models.Sequential()
multi_step_model.add(tf.keras.layers.LSTM(32,
                                          return_sequences=True,
                                          input_shape=x_train_multi.shape[-2:]))
multi_step_model.add(tf.keras.layers.LSTM(16, activation='relu'))
multi_step_model.add(tf.keras.layers.Dense(72))

multi_step_model.compile(optimizer=tf.keras.optimizers.RMSprop(clipvalue=1.0), loss='mae')

モデルがそれが訓練される前にどのように予測するかを見ましょう。

for x, y in val_data_multi.take(1):
  print (multi_step_model.predict(x).shape)
(256, 72)
multi_step_history = multi_step_model.fit(train_data_multi, epochs=EPOCHS,
                                          steps_per_epoch=EVALUATION_INTERVAL,
                                          validation_data=val_data_multi,
                                          validation_steps=50)
Train for 200 steps, validate for 50 steps
Epoch 1/10
200/200 [==============================] - 26s 132ms/step - loss: 0.4964 - val_loss: 0.3075
Epoch 2/10
200/200 [==============================] - 22s 112ms/step - loss: 0.3469 - val_loss: 0.2830
Epoch 3/10
200/200 [==============================] - 22s 111ms/step - loss: 0.3313 - val_loss: 0.2461
Epoch 4/10
200/200 [==============================] - 22s 111ms/step - loss: 0.2431 - val_loss: 0.2052
Epoch 5/10
200/200 [==============================] - 23s 114ms/step - loss: 0.1973 - val_loss: 0.1946
Epoch 6/10
200/200 [==============================] - 22s 112ms/step - loss: 0.2060 - val_loss: 0.2099
Epoch 7/10
200/200 [==============================] - 22s 109ms/step - loss: 0.1978 - val_loss: 0.2066
Epoch 8/10
200/200 [==============================] - 22s 109ms/step - loss: 0.1965 - val_loss: 0.2015
Epoch 9/10
200/200 [==============================] - 22s 109ms/step - loss: 0.1978 - val_loss: 0.1859
Epoch 10/10
200/200 [==============================] - 22s 110ms/step - loss: 0.1901 - val_loss: 0.1821
plot_train_history(multi_step_history, 'Multi-Step Training and validation loss')

 
マルチステップ未来を予測する

今は貴方のネットワークが未来を予測することをどの程度上手く学習したかを見ましょう。

for x, y in val_data_multi.take(3):
  multi_step_plot(x[0], y[0], multi_step_model.predict(x)[0])

 

Next steps

このチュートリアルは RNN を使用する時系列予報への簡単なイントロダクションです。今ではストックマーケットを予測することを試して億万長者になるかもしれません。

加えて、(uni/multivariate_data 関数の代わりに) データを生成するための generator も書くかもしれません、それはよりメモリ効率的です。この time series windowing ガイドを確認してそれをこのチュートリアルで使用することもできます。

更なる理解のために、Hands-on Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition の 15 章と Deep Learning with Python の 6 章を読んでも良いです。

 

以上



AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時:2021年10月13日(水)
会場:WEBセミナー
共催:クラスキャット、日本FLOW(株)
後援:働き方改革推進コンソーシアム
参加費: 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com