ホーム » ガウス過程

ガウス過程」カテゴリーアーカイブ

TensorFlow Probability : Tutorials : ガウス過程 潜在変数 (状態空間) モデル

TensorFlow Probability : Tutorials : ガウス過程 潜在変数 (状態空間) モデル (翻訳/解説)

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

* 本ページは、TensorFlow の本家サイトの TensorFlow Probability – Tutorials の次のページを翻訳した上で
適宜、補足説明したものです:

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

 

TensorFlow Probability : ガウス過程 潜在変数 (状態空間) モデル

潜在変数モデルは高次元データの隠れ構造を捕捉することを企てます。サンプルは主成分分析 (PCA) と因子分析を含みます。ガウス過程は「ノンパラメトリック」モデルでこれは局所相関構造と不確かさを柔軟に捕捉できます。ガウス過程潜在変数モデル (Lawrence, 2004) はこれらの概念を結合します。

 

背景: ガウス過程

ガウス過程は確率変数の任意のコレクションで任意の有限個の部分集合に渡る周辺分布が多変量正規分布であるようなものです。回帰のコンテキストにおける GP の詳細な見え方は、TensorFlow Probability のガウス過程回帰 をチェックしてください。

GP が構成されるコレクションの確率変数の各々をラベル付けするいわゆるインデックス集合を使用します。有限のインデックス集合の場合には、単に多変量正規分布を得ます。けれども無限コレクションを考慮するとき、GP は非常に興味深いです。$\mathbb{R}^D$ のようなインデックス集合の場合、そこでは $D$ 次元空間の総ての点について確率変数を持ち、GP はランダム関数に渡る分布として考えることができます。そのような GP からの単一のドローは、それが現実化するならば、$\mathbb{R}^D$ の総ての点に (結合的に正規分布に従う) 値を割り当てるでしょう。この colab では、ある $\mathbb{R}^D$ に渡る GP に注目します。

正規分布はそれらの最初と 2 番目の統計値で完全に決定されます — 実際に、正規分布を定義する一つの方法はその高次キュムラントが総てゼロであるものとしてです。これは GP の場合にもまた、当てはまります: 平均と共分散* を記述することで GP を完全に指定します。有限次元多変量正規分布については、平均はベクトルで共分散は正方 (= square) で、対称な正定値行列であることを思い出してください。無限次元 GP では、これらの構造はインデックス集合の各点で定義される平均関数, $m : \mathbb{R}^D \to \mathbb{R}$、そして共分散「カーネル」関数, $k : \mathbb{R}^D \times \mathbb{R}^D \to \mathbb{R}$ に一般化されます。カーネル関数は 正定値 であることが要求されます、これは本質的には、有限集合の点に制限されれば、それは正定値行列を生成することを言っています。

GP の構造の殆どはその共分散カーネル関数に由来します — この関数はサンプリングされた関数の値が近くの (or それほど近くはない) 点に渡りどのように変化するかを記述します。異なる共分散関数は滑らかさの異なる度合いに働きかけます。一つの一般的に使用されるカーネル関数は「指数二次 (= exponentiated quadratic)」 (a.k.a. ガウシアン、二乗指数 (= squared exponential)、動径基底関数 (= radial basis function)), $k(x, x’) = \sigma^2 e^{(x – x^2) / \lambda^2}$ です。他の例は伝統的なテキスト Gaussian Processes for Machine Learning 内に加えて、David Duvenaud の kernel cookbook ページ で概説されます。

 

GP の適用: 回帰と潜在変数モデル

GP を使用できる一つの方法は回帰のためです: 入力 $\{x_i\}_{i=1}^N$ (インデックス集合の要素)と観測 $\{y_i\}_{i=1}^N$ の形式で多くの観測されたデータが与えられたとき、点 $\{x_j^*\}_{j=1}^M$ の新しい集合における事後予測分布を形成するためにこれらを使用できます。分布は総て正規分布ですので、これは何某かの straightforward な線形代数に要約されます (しかし注意してください: 必要な計算はデータポイントの数で 3 次の実行時間を持ちそしてデータポイントの数で 2 次の空間を必要とします — これは GP の使用における主要な制限的要因で現在の研究の大半は正確な事後推論への計算的に実行可能な代替案に焦点を合わせています)。TFP における GP 回帰 で GP 回帰を詳しくカバーします。

GP を使用できるもう一つの方法は潜在変数モデルとしてです: 高次元観測 (e.g., 画像) のコレクションが与えられたとき、ある低次元潜在構造を推測することができます。潜在構造を条件とするとき、巨大な数の出力 (画像のピクセル) は互いに独立であることを仮定します。このモデルの訓練は以下から成ります :

  1. モデル・パラメータを最適化します (カーネル関数パラメータと、e.g. 観測ノイズ分散)、そして
  2. 各訓練観測 (画像) に対して、インデックス集合の対応する点位置を見つけます。最適化の総てはデータの周辺対数尤度を最大化することにより成されます。

 

インポート

import numpy as np
import tensorflow as tf
from tensorflow_probability import distributions as tfd
from tensorflow_probability import positive_semidefinite_kernels as tfk

numpy と matplotlib から対話的な名前空間を取り込みます。

def reset_session():
  """Creates a new global, interactive session in Graph-mode."""
  global sess
  try:
    tf.reset_default_graph()
    sess.close()
  except:
    pass
  sess = tf.InteractiveSession()

reset_session()

 

MNIST データをロードする

# Load the MNIST data set and isolate a subset of it.
(x_train, y_train), (_, _) = tf.keras.datasets.mnist.load_data()
N = 1000
small_x_train = x_train[:N, ...].astype(np.float64) / 256.
small_y_train = y_train[:N]

 

訓練可能な変数を準備する

3 モデル・パラメータと潜在入力を結合的に訓練していきます。

# Create some trainable model parameters. We also constrain them to be strictly
# positive
amplitude = np.finfo(np.float64).eps + tf.nn.softplus(
    tf.get_variable(name='amplitude',
                    dtype=tf.float64,
                    initializer=np.float64(1.)))

length_scale = np.finfo(np.float64).eps + tf.nn.softplus(
    tf.get_variable(name='length_scale',
                    dtype=tf.float64, 
                    initializer=np.float64(1.)))

observation_noise_variance = np.finfo(np.float64).eps + tf.nn.softplus(
    tf.get_variable(name='observation_noise_variance',
                    dtype=tf.float64, 
                    initializer=np.float64(1.)))
# We need to flatten the images and, somewhat unintuitively, transpose from
# shape [100, 784] to [784, 100]. This is because the 784 pixels will be
# treated as *independent* conditioned on the latent inputs, meaning we really
# have a batch of 784 GP's with 100 index_points.
observations_ = small_x_train.reshape(N, -1).transpose()

# Create a collection of N 2-dimensional index points that will represent our
# latent embeddings of the data. (Lawrence, 2004) prescribes initializing these
# with PCA, but a random initialization actually gives not-too-bad results, so
# we use this for simplicity. For a fun exercise, try doing the
# PCA-initialization yourself!
init_ = np.random.normal(size=(N, 2))
latent_index_points = tf.get_variable(
    name='latent_index_points',
    dtype=tf.float64,
    initializer=init_)

 

モデルと訓練 ops を構築する

# Create our kernel and GP distribution
kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale)

gp = tfd.GaussianProcess(
    kernel=kernel,
    index_points=latent_index_points,
    observation_noise_variance=observation_noise_variance)

# Compute the log probability density of each of the observations. This is what
# we will maximize below.
log_probs = gp.log_prob(observations_, name='log_prob')

# Our training loss is the negative log likelihood of the observations. Since
# the observations are IID, the log likelihoods are summed. We normalize the sum
# (take the average) to reduce the risk of extreme values subject to floating
# point issues.
loss = -tf.reduce_mean(log_probs)
optimizer = tf.train.AdamOptimizer(learning_rate=.1)
train_op = optimizer.minimize(loss)

 

予測モデルとサンプリング ops を構築する

# We'll draw samples at evenly spaced points on a 10x10 grid in the latent
# input space. 
sample_grid_points = 10
grid_ = np.linspace(-4, 4, sample_grid_points).astype(np.float64)
# Create a 10x10 grid of 2-vectors, for a total shape [10, 10, 2]
grid_ = np.stack(np.meshgrid(grid_, grid_), axis=-1)

# This part's a bit subtle! What we defined above was a batch of 784 (=28x28)
# independent GP distributions over the input space. Each one corresponds to a
# single pixel of an MNIST image. Now what we'd like to do is draw 100 (=10x10)
# *independent* samples, each one separately conditioned on all the observations
# as well as the learned latent input locations above.
#
# The GP regression model below will define a batch of 784 independent
# posteriors. We'd like to get 100 independent samples each at a different
# latent index point. We could loop over the points in the grid, but that might
# be a bit slow. Instead, we can vectorize the computation by tacking on *even
# more* batch dimensions to our GaussianProcessRegressionModel distribution.
# In the below grid_ shape, we have concatentaed
#   1. batch shape: [sample_grid_points, sample_grid_points, 1]
#   2. number of examples: [1]
#   3. number of latent input dimensions: [2]
# The `1` in the batch shape will broadcast with 784. The final result will be
# samples of shape [10, 10, 784, 1]. The `1` comes from the "number of examples"
# and we can just `np.squeeze` it off.
grid_ = grid_.reshape(sample_grid_points, sample_grid_points, 1, 1, 2)

# Create the GPRegressionModel instance which represents the posterior
# predictive at the grid of new points.
gprm = tfd.GaussianProcessRegressionModel(
    kernel=kernel,
    index_points=grid_,
    observation_index_points=latent_index_points,
    observations=observations_)

# Create a sample operation in the graph.
samples = gprm.sample()

 

訓練と結果の潜在埋め込みのプロット

# Initialize variables and train!
sess.run(tf.global_variables_initializer())
num_iters = 100
log_interval = 20
lips_ = np.zeros((num_iters, N, 2), np.float64)
for i in range(num_iters):
  _, loss_, lips_[i] = sess.run([train_op, loss, latent_index_points])
  if i % log_interval == 0 or i + 1 == num_iters:
    print("Loss at step %d: %f" % (i, loss_))
Loss at step 0: 869611.863774
Loss at step 20: 330985.762144
Loss at step 40: -90885.405676
Loss at step 60: -182680.904868
Loss at step 80: -207781.362585
Loss at step 99: -212932.604949

 

結果をプロットする

# Plot the latent locations before and after training
plt.figure(figsize=(7, 7))
plt.title("Before training")
plt.grid('off')
plt.scatter(x=init_[:, 0], y=init_[:, 1],
           c=y_train[:N], cmap=plt.get_cmap('Paired'), s=50)
plt.show()

plt.figure(figsize=(7, 7))
plt.title("After training")
plt.grid('off')
plt.scatter(x=lips_[-1, :, 0], y=lips_[-1, :, 1],
           c=y_train[:N], cmap=plt.get_cmap('Paired'), s=50)
plt.show()

 

データ上で条件付けられたサンプルのドローと潜在埋め込み

潜在空間の 2-d グリッド上の 100 点でサンプリングします。

samples_ = sess.run(samples)

# Plot the grid of samples at new points. We do a bit of tweaking of the samples
# first, squeezing off extra 1-shapes and normalizing the values.
samples_ = np.squeeze(samples_)
samples_ = ((samples_ -
             samples_.min(-1, keepdims=True)) /
            (samples_.max(-1, keepdims=True) -
             samples_.min(-1, keepdims=True)))
samples_ = samples_.reshape(sample_grid_points, sample_grid_points, 28, 28)
samples_ = samples_.transpose([0, 2, 1, 3])
samples_ = samples_.reshape(28 * sample_grid_points, 28 * sample_grid_points)
plt.figure(figsize=(7, 7))
ax = plt.subplot()
ax.grid('off')
ax.imshow(-samples_, interpolation='none', cmap='Greys')
plt.show()

 

以上






TensorFlow Probability : Tutorials : ガウス過程回帰

TensorFlow Probability : Tutorials : ガウス過程回帰 (翻訳/解説)

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

* 本ページは、TensorFlow の本家サイトの TensorFlow Probability – Tutorials の次のページを翻訳した上で
適宜、補足説明したものです:

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

 

TensorFlow Probability : ガウス過程回帰

この colab では、TensorFlow と TensorFlow Probability を使用してガウス過程回帰を探究します。ある知られている関数(s) からのノイズを持つ観測を生成して GP モデルをそれらのデータに適合させます。それから GP 事後分布からサンプリングされた関数値をそれらの領域でグリッドに渡りプロットします。

 

背景

$\mathcal{X}$ を任意の集合とします。ガウス過程 (GP) は $\mathcal{X}$ によりインデックス付けられた確率変数のコレクションで、$\{X_1, \ldots, X_n\} \subset \mathcal{X}$ を任意の有限な部分集合とする場合に、周辺密度関数 $p(X_1 = x_1, \ldots, X_n = x_n)$ が多変量ガウス分布であるようなものです。任意のガウス分布はその最初と 2 番目の中心モーメント (平均と共分散) で完全に指定され、そして GP のものも例外ではありません。GP はその平均関数 $\mu : \mathcal{X} \to \mathbb{R}$ と共分散関数 $k : \mathcal{X} \times \mathcal{X} \to \mathbb{R}$ によって完全に指定できます。GP の表現力の殆どは共分散関数の選択にカプセル化されています。様々な理由で、共分散関数はまたカーネル関数として参照されます。対照的 (= symmetirc) で正定値 (= positive-definite) であることだけが要求されます (Rasmussen & Williams の Ch. 4 参照)。下では指数二次 (= ExponentiatedQuadratic) 共分散カーネルを活用します。その形式は :
\[
k(x, x’) := \sigma^2 \exp \left( \frac{\|x – x’\|^2}{\lambda^2} \right)
\]

$\sigma^2$ は「振幅 (= amplitude)」そして $\lambda$ は長さスケールと呼ばれます。カーネル・パラメータは最大尤度最適化手続きを通して選択可能です。

GP からのフル・サンプルは空間全体 $\mathcal{X}$ に渡る実数値関数から成りそして実際には認識することは実行不可能です; しばしば (そこでサンプルを観測するために) 点の集合を選択してそしてそれらの点で関数値を描画します。これは適切な (有限次元の) 多変量ガウス分布からサンプリングすることで獲得されます。

上の定義に従えば、任意の有限次元多変量ガウス分布もまたガウス過程であることに注意してください。通常は、GP に言及するとき、インデックス集合はある $\mathbb{R}^n$ であることが暗黙的でここでも実際にこの仮定をします。

機械学習におけるガウス過程の一般的な応用はガウス過程回帰です。考え方は、有限個の点 $\{x_1, \ldots x_N\}$ における関数のノイズを伴う観測 $\{y_1, \ldots, y_N\}$ が与えられたとき未知の関数を推定することを望むことです。生成過程を推測します :
\[
\begin{align}
f \sim \: & \textsf{GaussianProcess}\left(
\text{mean_fn}=\mu(x),
\text{covariance_fn}=k(x, x’)\right) \\
y_i \sim \: & \textsf{Normal}\left(
\text{loc}=f(x_i),
\text{scale}=\sigma\right), i = 1, \ldots, N
\end{align}
\]

上で記されたように、サンプリングされた関数は計算することは不可能です、何故ならば無限の数の点におけるその値を必要とするからです。代わりに、多変量ガウス分布からの有限個のサンプルを考えます。

$$
\begin{gather}
\begin{bmatrix}
f(x_1) \\
\vdots \\
f(x_N)
\end{bmatrix}
\sim
\textsf{MultivariateNormal} \left( \:
\text{loc}=
\begin{bmatrix}
\mu(x_1) \\
\vdots \\
\mu(x_N)
\end{bmatrix} \:,\:
\text{scale}=
\begin{bmatrix}
k(x_1, x_1) & \cdots & k(x_1, x_N) \\
\vdots & \ddots & \vdots \\
k(x_N, x_1) & \cdots & k(x_N, x_N) \\
\end{bmatrix}^{1/2}
\: \right)
\end{gather} \\
y_i \sim \textsf{Normal} \left(
\text{loc}=f(x_i),
\text{scale}=\sigma
\right)
$$

共分散行列上の指数 $\frac{1}{2}$ に注意してください: これはコレスキー分解を表しています。コレスキーを計算することは必要です、何故ならば MVN は location-scale family 分布だからです。不幸にも、コレスキー分解は計算的に高価で、$O(N^3)$ 時間と $O(N^2)$ 空間がかかります。大半の GP 文献はこの表面上は無害で小さな指数を処理することに焦点を置いています。

事前分布平均関数を定数、しばしばゼロに取ることは一般的です。また、幾つかの表記法の慣習は便利です。サンプリングされた関数値の有限ベクトルのために $\mathbf{f}$ としばしば書きます。多くの興味深い表記法が、入力ペアへの $k$ の適用に由来する共分散行列のために使用されます。(Quiñonero-Candela, 2005) に従って、行列の成分は特定の入力点における関数値の共分散であることに注意します。こうして共分散行列を $K_{AB}$ として示すことができます、そこでは $A$ と $B$ は与えられた行列次元に沿った関数値のコレクションの幾つかの indicator です。

例えば、含蓄される潜在関数値 $\mathbf{f}$ を持つ観測されたデータ $(\mathbf{x}, \mathbf{y})$ が与えられたとき、次のように書けます :

$$
K_{\mathbf{f},\mathbf{f}} = \begin{bmatrix}
k(x_1, x_1) & \cdots & k(x_1, x_N) \\
\vdots & \ddots & \vdots \\
k(x_N, x_1) & \cdots & k(x_N, x_N) \\
\end{bmatrix}
$$

同様に、以下の内のように、入力の集合を混合できます :

$$
K_{\mathbf{f},*} = \begin{bmatrix}
k(x_1, x^*_1) & \cdots & k(x_1, x^*_T) \\
\vdots & \ddots & \vdots \\
k(x_N, x^*_1) & \cdots & k(x_N, x^*_T) \\
\end{bmatrix}
$$

ここで $N$ 訓練入力、そして $T$ テスト入力があると仮定します。そして上の生成過程は次のように簡潔に書くことができます :

$$
\begin{align}
\mathbf{f} \sim \: & \textsf{MultivariateNormal} \left(
\text{loc}=\mathbf{0},
\text{scale}=K_{\mathbf{f},\mathbf{f}}^{1/2}
\right) \\
y_i \sim \: & \textsf{Normal} \left(
\text{loc}=f_i,
\text{scale}=\sigma \right), i = 1, \ldots, N
\end{align}
$$

最初の行のサンプリング演算は (一つの) 多変量正規分布からの $N$ 関数値の有限集合を生成します — 上の GP ドロー記法内のような関数全体 (= an entire function) ではありません。2 番目の行は固定された観測ノイズ $\sigma^2$ を持ち、様々な関数値を中心とする単変量正規分布 (= univariate Gaussians) からの $N$ ドローのコレクションを表します。

上の適所にある生成モデルで、事後分布問題を考えることに進めます。これは上の仮定からの観測されたノイズを持つデータ上で条件付けられた、テスト点の新しい集合における関数値に渡る事後分布を生成します。

上の適所にある表記で、相当する入力と訓練データ上で条件付けられた未来 (ノイズを持つ) 観測に渡る事後予測分布を次のように簡潔に書くことができます (より詳細については、Rasmussen & Williams の 2.2 参照)。
$$
\mathbf{y}^* \mid \mathbf{x}^*, \mathbf{x}, \mathbf{y} \sim \textsf{Normal} \left(
\text{loc}=\mathbf{\mu}^*,
\text{scale}=(\Sigma^*)^{1/2}
\right)
$$

ここで
$$
\mathbf{\mu}^* = K_{*,\mathbf{f}}\left(K_{\mathbf{f},\mathbf{f}} + \sigma^2 I \right)^{-1} \mathbf{y}
$$

そして
$$
\Sigma^* = K_{*,*} – K_{*,\mathbf{f}}
\left(K_{\mathbf{f},\mathbf{f}} + \sigma^2 I \right)^{-1} K_{\mathbf{f},*}
$$

 

インポート

import numpy as np
import tensorflow as tf
from mpl_toolkits.mplot3d import Axes3D
from tensorflow_probability import distributions as tfd
from tensorflow_probability import positive_semidefinite_kernels as tfk

%pylab inline
# Configure plot defaults
plt.rcParams['axes.facecolor'] = 'white'
plt.rcParams['grid.color'] = '#666666'
%config InlineBackend.figure_format = 'png'

numpy と matplotlib から対話的な名前空間を取り込んでいます。

 

例: ノイズを持つ正弦波データ上の正確な GP 回帰

ここではノイズを持つ正弦波から訓練データを生成し、それから GP 回帰モデルの事後分布から多くの曲線をサンプリングします。カーネル・ハイパーパラメータを最適化するために Adam を使用します (事前分布のもとのデータの負の対数尤度を最小化します)。訓練している曲線に続いて、正解関数と事後サンプルをプロットします。

def reset_session():
  """Creates a new global, interactive session in Graph-mode."""
  global sess
  try:
    tf.reset_default_graph()
    sess.close()
  except:
    pass
  sess = tf.InteractiveSession()

reset_session()
def sinusoid(x):
  return np.sin(3 * np.pi * x[..., 0])

def generate_1d_data(num_training_points, observation_noise_variance):
  """Generate noisy sinusoidal observations at a random set of points.

  Returns:
     observation_index_points, observations
  """
  index_points_ = np.random.uniform(-1., 1., (num_training_points, 1))
  index_points_ = index_points_.astype(np.float64)
  # y = f(x) + noise
  observations_ = (sinusoid(index_points_) +
                   np.random.normal(loc=0,
                                    scale=np.sqrt(observation_noise_variance),
                                    size=(num_training_points)))
  return index_points_, observations_
# Generate training data with a known noise level (we'll later try to recover
# this value from the data).
NUM_TRAINING_POINTS = 100
observation_index_points_, observations_ = generate_1d_data(
    num_training_points=NUM_TRAINING_POINTS,
    observation_noise_variance=.1)
# Create the trainable model parameters, which we'll subsequently optimize.
# Note that we constrain them to be strictly positive.
amplitude = (np.finfo(np.float64).tiny +
             tf.nn.softplus(tf.Variable(initial_value=1.,
                                        name='amplitude',
                                        dtype=np.float64)))
length_scale = (np.finfo(np.float64).tiny +
                tf.nn.softplus(tf.Variable(initial_value=1.,
                                           name='length_scale',
                                           dtype=np.float64)))

observation_noise_variance = (
    np.finfo(np.float64).tiny +
    tf.nn.softplus(tf.Variable(initial_value=1e-6,
                               name='observation_noise_variance',
                               dtype=np.float64)))
# Create the covariance kernel, which will be shared between the prior (which we
# use for maximum likelihood training) and the posterior (which we use for
# posterior predictive sampling)
kernel = tfk.ExponentiatedQuadratic(amplitude, length_scale)
# Create the GP prior distribution, which we will use to train the model
# parameters.
gp = tfd.GaussianProcess(
    kernel=kernel,
    index_points=observation_index_points_,
    observation_noise_variance=observation_noise_variance)

# This lets us compute the log likelihood of the observed data. Then we can
# maximize this quantity to find optimal model parameters.
log_likelihood = gp.log_prob(observations_)
# Define the optimization ops for maximizing likelihood (minimizing neg
# log-likelihood!)
optimizer = tf.train.AdamOptimizer(learning_rate=.01)
train_op = optimizer.minimize(-log_likelihood)
# Now we optimize the model parameters.
num_iters = 1000
# Store the likelihood values during training, so we can plot the progress
lls_ = np.zeros(num_iters, np.float64)
sess.run(tf.global_variables_initializer())
for i in range(num_iters):
  _, lls_[i] = sess.run([train_op, log_likelihood])

[amplitude_,
 length_scale_,
 observation_noise_variance_] = sess.run([
    amplitude,
    length_scale,
    observation_noise_variance])
print('Trained parameters:'.format(amplitude_))
print('amplitude: {}'.format(amplitude_))
print('length_scale: {}'.format(length_scale_))
print('observation_noise_variance: {}'.format(observation_noise_variance_))
Trained parameters:
amplitude: 0.737212035424
length_scale: 0.120468090569
observation_noise_variance: 0.0978894813992
# Plot the loss evolution
plt.figure(figsize=(12, 4))
plt.plot(lls_)
plt.xlabel("Training iteration")
plt.ylabel("Log marginal likelihood")
plt.show()

 

# Having trained the model, we'd like to sample from the posterior conditioned
# on observations. We'd like the samples to be at points other than the training
# inputs.
predictive_index_points_ = np.linspace(-1.2, 1.2, 200, dtype=np.float64)
# Reshape to [200, 1] -- 1 is the dimensionality of the feature space.
predictive_index_points_ = predictive_index_points_[..., np.newaxis]

gprm = tfd.GaussianProcessRegressionModel(
    kernel=kernel,  # Reuse the same kernel instance, with the same params
    index_points=predictive_index_points_,
    observation_index_points=observation_index_points_,
    observations=observations_,
    observation_noise_variance=observation_noise_variance,
    predictive_noise_variance=0.)

# Create op to draw  50 independent samples, each of which is a *joint* draw
# from the posterior at the predictive_index_points_. Since we have 200 input
# locations as defined above, this posterior distribution over corresponding
# function values is a 200-dimensional multivariate Gaussian distribution!
num_samples = 50
samples = gprm.sample(num_samples)
# Draw samples and visualize.
samples_ = sess.run(samples)

# Plot the true function, observations, and posterior samples.
plt.figure(figsize=(12, 4))
plt.plot(predictive_index_points_, sinusoid(predictive_index_points_),
         label='True fn')
plt.scatter(observation_index_points_[:, 0], observations_,
            label='Observations')
for i in range(num_samples):
  plt.plot(predictive_index_points_, samples_[i, :], c='r', alpha=.1,
           label='Posterior Sample' if i == 0 else None)
leg = plt.legend()
for lh in leg.legendHandles: 
    lh.set_alpha(1)
plt.xlabel(r"Index points ($\mathbb{R}^1)")
plt.ylabel("Observation space")
plt.show()

 
Note: 上のコードを何回か実行する場合、時にはそれは素晴らしく見えて他の回にはそれは酷く見えます!パラメータを訓練する最大尤度は非常に敏感で時々貧弱なモデルに収束します。最善のアプローチはモデル・ハイパーパラメータを周辺化するために MCMC を使用することです。

 

以上






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