├── .gitignore
├── README.md
├── tfp_resnet.py
└── tfp_bgmm_MultivariateNormalTriL_MCMC.ipynb


/.gitignore:
--------------------------------------------------------------------------------
1 | saved_models/
2 | .ipynb_checkpoints
3 | *.pdf
4 | *.png
5 | *.h5


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # tfp-tutorial
 2 | My own implementations of some examples using TensorFlow Probability for tutorial purposes
 3 | 
 4 | ## Tutorials
 5 | 
 6 | * [Bayesian Neural Networks](tfp_bnn.ipynb)
 7 | * [Bayesian Gaussian Mixture Model (MultivariateNormalDiag components) (Stochastic Variational Inference)](tfp_bgmm_MultivariateNormalDiag_SVI.ipynb)
 8 | * [Bayesian Gaussian Mixture Model (MultivariateNormalTriL components) (Stochastic Variational Inference)](tfp_bgmm_MultivariateNormalTriL_SVI.ipynb)
 9 | * [Bayesian Gaussian Mixture Model (MultivariateNormalTriL components) (Markov chain Monte Carlo)](tfp_bgmm_MultivariateNormalTriL_MCMC.ipynb)
10 | * [ResNet](tfp_resnet.py)
11 | 
12 | ## References
13 | 
14 | ### TensorFlow Probability
15 | * [Project](https://www.tensorflow.org/probability)
16 | * [GitHub](https://github.com/tensorflow/probability)
17 | 
18 | ### ResNet
19 | * v1: [Deep Residual Learning for Image Recognition](https://arxiv.org/pdf/1512.03385.pdf)
20 | * v2: [Identity Mappings in Deep Residual Networks](https://arxiv.org/pdf/1603.05027.pdf)


--------------------------------------------------------------------------------
/tfp_resnet.py:
--------------------------------------------------------------------------------
  1 | """
  2 | Trains a ResNet on the CIFAR10 dataset using Keras and Tensorflow Probability.
  3 | 
  4 | ResNet v1:
  5 | [Deep Residual Learning for Image Recognition](https://arxiv.org/pdf/1512.03385.pdf)
  6 | 
  7 | ResNet v2:
  8 | [Identity Mappings in Deep Residual Networks](https://arxiv.org/pdf/1603.05027.pdf)
  9 | 
 10 | Model parameter
 11 | -----------------------------------------------------------------------------------
 12 |           |             | 200-epoch | Orig Paper| 200-epoch | Orig Paper| sec/epoch
 13 | Model     | n_res_block | ResNet v1 | ResNet v1 | ResNet v2 | ResNet v2 | GTX1080Ti
 14 |           |    v1(v2)   | %Accuracy | %Accuracy | %Accuracy | %Accuracy | v1 (v2)
 15 | -----------------------------------------------------------------------------------
 16 | ResNet20  |     3 (2)   | 92.16     | 91.25     | -----     | -----     | 35 (---)
 17 | ResNet32  |     5(NA)   | 92.46     | 92.49     | NA        | NA        | 50 ( NA)
 18 | ResNet44  |     7(NA)   | 92.50     | 92.83     | NA        | NA        | 70 ( NA)
 19 | ResNet56  |     9 (6)   | 92.71     | 93.03     | 93.01     | NA        | 90 (100)
 20 | ResNet110 |    18(12)   | 92.65     | 93.39+-.16| 93.15     | 93.63     | 165(180)
 21 | ResNet164 |    27(18)   | -----     | 94.07     | -----     | 94.54     | ---(---)
 22 | ResNet1001|   NA(111)   | -----     | 92.39     | -----     | 95.08+-.14| ---(---)
 23 | -----------------------------------------------------------------------------------
 24 | """
 25 | from __future__ import print_function
 26 | import tensorflow as tf
 27 | import tensorflow_probability as tfp
 28 | import os
 29 | os.environ['KERAS_BACKEND'] = 'tensorflow'  # set up tensorflow backend for keras
 30 | import keras
 31 | import numpy as np
 32 | 
 33 | 
 34 | def lr_schedule(epoch):
 35 |     """
 36 |     Learning Rate Schedule
 37 | 
 38 |     Learning rate is scheduled to be reduced after 80, 120, 160, 180 epochs.
 39 |     Called automatically every epoch as part of callbacks during training.
 40 | 
 41 |     # Arguments
 42 |         epoch (int): The number of epochs
 43 | 
 44 |     # Returns
 45 |         lr (float32): learning rate
 46 |     """
 47 |     lr = 1e-3
 48 |     if epoch > 180:
 49 |         lr *= 0.5e-3
 50 |     elif epoch > 160:
 51 |         lr *= 1e-3
 52 |     elif epoch > 120:
 53 |         lr *= 1e-2
 54 |     elif epoch > 80:
 55 |         lr *= 1e-1
 56 |     print('Learning rate: ', lr)
 57 |     return lr
 58 | 
 59 | 
 60 | def get_kernel_posterior_fn(kernel_posterior_scale_mean=-9.0,
 61 |                             kernel_posterior_scale_stddev=0.1,
 62 |                             kernel_posterior_scale_constraint=0.2):
 63 |     """
 64 |     Get the kernel posterior distribution
 65 | 
 66 |     # Arguments
 67 |         kernel_posterior_scale_mean (float): kernel posterior's scale mean.
 68 |         kernel_posterior_scale_stddev (float): the initial kernel posterior's scale stddev.
 69 |           ```
 70 |           q(W|x) ~ N(mu, var),
 71 |           log_var ~ N(kernel_posterior_scale_mean, kernel_posterior_scale_stddev)
 72 |           ````
 73 |         kernel_posterior_scale_constraint (float): the log value to constrain the log variance throughout training.
 74 |           i.e. log_var <= log(kernel_posterior_scale_constraint).
 75 | 
 76 |     # Returns
 77 |         kernel_posterior_fn: kernel posterior distribution
 78 |     """
 79 | 
 80 |     def _untransformed_scale_constraint(t):
 81 |         return tf.clip_by_value(t, -1000, tf.math.log(kernel_posterior_scale_constraint))
 82 | 
 83 |     kernel_posterior_fn = tfp.layers.default_mean_field_normal_fn(
 84 |         untransformed_scale_initializer=tf.random_normal_initializer(
 85 |             mean=kernel_posterior_scale_mean,
 86 |             stddev=kernel_posterior_scale_stddev),
 87 |         untransformed_scale_constraint=_untransformed_scale_constraint)
 88 |     return kernel_posterior_fn
 89 | 
 90 | 
 91 | def get_kernel_divergence_fn(train_size, w=1.0):
 92 |     """
 93 |     Get the kernel Kullback-Leibler divergence function
 94 | 
 95 |     # Arguments
 96 |         train_size (int): size of the training dataset for normalization
 97 |         w (float): weight to the function
 98 | 
 99 |     # Returns
100 |         kernel_divergence_fn: kernel Kullback-Leibler divergence function
101 |     """
102 |     def kernel_divergence_fn(q, p, _):  # need the third ignorable argument
103 |         kernel_divergence = tfp.distributions.kl_divergence(q, p) / tf.cast(train_size, tf.float32)
104 |         return w * kernel_divergence
105 |     return kernel_divergence_fn
106 | 
107 | 
108 | def get_neg_log_likelihood_fn(bayesian=False):
109 |     """
110 |     Get the negative log-likelihood function
111 |     # Arguments
112 |         bayesian(bool): Bayesian neural network (True) or point-estimate neural network (False)
113 | 
114 |     # Returns
115 |         a negative log-likelihood function
116 |     """
117 |     if bayesian:
118 |         def neg_log_likelihood_bayesian(y_true, y_pred):
119 |             labels_distribution = tfp.distributions.Categorical(logits=y_pred)
120 |             log_likelihood = labels_distribution.log_prob(tf.argmax(input=y_true, axis=1))
121 |             loss = -tf.reduce_mean(input_tensor=log_likelihood)
122 |             return loss
123 |         return neg_log_likelihood_bayesian
124 |     else:
125 |         def neg_log_likelihood(y_true, y_pred):
126 |             y_pred_softmax = keras.layers.Activation('softmax')(y_pred)  # logits to softmax
127 |             loss = keras.losses.categorical_crossentropy(y_true, y_pred_softmax)
128 |             return loss
129 |         return neg_log_likelihood
130 | 
131 | 
132 | def get_categorical_accuracy_fn(y_true, y_pred):
133 |     y_pred_softmax = keras.layers.Activation('softmax')(y_pred)  # logits to softmax
134 |     acc = keras.metrics.categorical_accuracy(y_true, y_pred_softmax)
135 |     return acc
136 | 
137 | 
138 | class KLLossScheduler(tf.keras.callbacks.Callback):
139 |     def __init__(self, update_per_batch=False, n_silent_epoch=5, n_annealing_epoch=50, verbose=0):
140 |         self.update_per_batch = update_per_batch
141 |         self.n_silent_epoch = n_silent_epoch
142 |         self.n_annealing_epoch = n_annealing_epoch
143 |         self.verbose = verbose
144 |         super(KLLossScheduler, self).__init__()
145 |     def on_batch_begin(self, batch, logs=None):
146 |         if self.update_per_batch:
147 |             n_batch_per_epoch = int(np.ceil(self.params['samples'] / self.params['batch_size']))
148 |             idx_total_batch = (self.epoch - self.n_silent_epoch) * n_batch_per_epoch + batch + 1
149 |             kl_weight = (idx_total_batch / n_batch_per_epoch) / self.n_annealing_epoch
150 |             kl_weight = np.maximum(0.0, np.minimum(kl_weight, 1.0))
151 |             self.kl_weight = kl_weight
152 |             if self.verbose > 0:
153 |                 print('\nBatch: {}, KL Divergence Loss Weight = {:.6f}'.format(batch+1, kl_weight))
154 |             for l in self.model.layers:
155 |                 for id_w, w in enumerate(l.weights):
156 |                     if 'kl_loss_weight' in w.name:
157 |                         l_weights = l.get_weights()
158 |                         l.set_weights([*l_weights[:id_w], kl_weight, *l_weights[id_w+1:]])
159 |     def on_epoch_begin(self, epoch, logs=None):
160 |         self.epoch = epoch
161 |         if not self.update_per_batch:
162 |             kl_weight = (epoch - self.n_silent_epoch + 1) / self.n_annealing_epoch
163 |             kl_weight = np.maximum(0.0, np.minimum(kl_weight, 1.0))
164 |             self.kl_weight = kl_weight
165 |             if self.verbose > 0:
166 |                 print('\nEpoch: {}, KL Divergence Loss Weight = {:.6f}'.format(epoch+1, kl_weight))
167 |             for l in self.model.layers:
168 |                 for id_w, w in enumerate(l.weights):
169 |                     if 'kl_loss_weight' in w.name:
170 |                         l_weights = l.get_weights()
171 |                         l.set_weights([*l_weights[:id_w], kl_weight, *l_weights[id_w+1:]])
172 |     def on_epoch_end(self, epoch, logs={}):
173 |         print('KL Divergence Weight = {:.6f}, KL Divergence Loss = {:.4f}'.format(self.kl_weight,
174 |                                                                                   sum(self.model.losses).eval(session=tf.keras.backend.get_session())))
175 | 
176 | 
177 | def resnet_layer(inputs, train_size,
178 |                  n_filter=16,
179 |                  kernel_size=3,
180 |                  strides=1,
181 |                  activation='relu',
182 |                  batch_normalization=True,
183 |                  conv_first=True,
184 |                  bayesian=False):
185 |     """2D Convolution-Batch Normalization-Activation stack builder
186 | 
187 |     # Arguments
188 |         inputs (tensor): input tensor from input image or previous layer
189 |         n_filter (int): Conv2D number of filters
190 |         kernel_size (int): Conv2D square kernel dimensions
191 |         strides (int): Conv2D square stride dimensions
192 |         activation (string): activation name
193 |         batch_normalization (bool): whether to include batch normalization
194 |         conv_first (bool): conv-bn-activation (True) or bn-activation-conv (False)
195 |         bayesian (bool): implement Bayesian neural network (True) or point-estimate neural network (False)
196 | 
197 |     # Returns
198 |         x (tensor): tensor as input to the next layer
199 |     """
200 |     if bayesian:
201 |         # scale the KL divergence function to avoid the loss function being over-regularized
202 |         conv = tfp.layers.Convolution2DFlipout(n_filter,
203 |                                                kernel_size=kernel_size,
204 |                                                strides=strides,
205 |                                                padding='same',
206 |                                                kernel_posterior_fn=get_kernel_posterior_fn(),
207 |                                                kernel_divergence_fn=None)
208 |         w = conv.add_weight(name=conv.name+'/kl_loss_weight', shape=(), initializer=tf.initializers.constant(0.0), trainable=False)
209 |         conv.kernel_divergence_fn = get_kernel_divergence_fn(train_size, w)
210 |     else:
211 |         conv = keras.layers.Conv2D(n_filter,
212 |                                    kernel_size=kernel_size,
213 |                                    strides=strides,
214 |                                    padding='same',
215 |                                    kernel_initializer='he_normal',
216 |                                    kernel_regularizer=keras.regularizers.l2(1e-4))
217 |     x = inputs
218 |     if conv_first:
219 |         x = conv(x)
220 |         if batch_normalization:
221 |             x = keras.layers.BatchNormalization()(x)
222 |         if activation is not None:
223 |             x = keras.layers.Activation(activation)(x)
224 |     else:
225 |         if batch_normalization:
226 |             x = keras.layers.BatchNormalization()(x)
227 |         if activation is not None:
228 |             x = keras.layers.Activation(activation)(x)
229 |         x = conv(x)
230 |     return x
231 | 
232 | 
233 | def resnet_v1(input_shape, n_res_block, train_size, n_class=10, bayesian=False):
234 |     """ResNet Version 1 Model builder [a]
235 | 
236 |     Stacks of 2 x (3 x 3) Conv2D-BN-ReLU
237 |     Last ReLU is after the shortcut connection.
238 |     At the beginning of each stage, the feature map size is halved (downsampled)
239 |     by a convolutional layer with strides=2, while the number of filters is
240 |     doubled. Within each stage, the layers have the same number filters and the
241 |     same number of filters.
242 |     Features maps sizes:
243 |     stage 0: 32x32, 16
244 |     stage 1: 16x16, 32
245 |     stage 2:  8x8,  64
246 |     The Number of parameters is approx the same as Table 6 of [a]:
247 |     ResNet20 0.27M
248 |     ResNet32 0.46M
249 |     ResNet44 0.66M
250 |     ResNet56 0.85M
251 |     ResNet110 1.7M
252 | 
253 |     # Arguments
254 |         input_shape (tensor): shape of input image tensor
255 |         n_res_block (int): number of residual blocks
256 |         n_class (int): number of classes (CIFAR10 has 10)
257 |         bayesian (bool): implement Bayesian neural network (True) or point-estimate neural network (False)
258 | 
259 |     # Returns
260 |         model (Model): Keras model instance
261 |     """
262 |     n_filter = 16
263 | 
264 |     inputs = keras.layers.Input(shape=input_shape)
265 |     x = resnet_layer(inputs=inputs, train_size=train_size, bayesian=bayesian)
266 |     # Instantiate the stack of residual units
267 |     for stack in range(3):
268 |         for res_block in range(n_res_block):
269 |             strides = 1
270 |             if stack > 0 and res_block == 0:  # first layer but not first stack
271 |                 strides = 2  # downsample
272 |             y = resnet_layer(inputs=x, train_size=train_size,
273 |                              n_filter=n_filter,
274 |                              strides=strides,
275 |                              bayesian=bayesian)
276 |             y = resnet_layer(inputs=y, train_size=train_size,
277 |                              n_filter=n_filter,
278 |                              activation=None,
279 |                              bayesian=bayesian)
280 |             if stack > 0 and res_block == 0:  # first layer but not first stack
281 |                 # linear projection residual shortcut connection to match
282 |                 # changed dims
283 |                 x = resnet_layer(inputs=x, train_size=train_size,
284 |                                  n_filter=n_filter,
285 |                                  kernel_size=1,
286 |                                  strides=strides,
287 |                                  activation=None,
288 |                                  batch_normalization=False,
289 |                                  bayesian=bayesian)
290 |             x = keras.layers.add([x, y])
291 |             x = keras.layers.Activation('relu')(x)
292 |         n_filter *= 2
293 | 
294 |     # Add classifier on top.
295 |     # v1 does not use BN after last shortcut connection-ReLU
296 |     x = keras.layers.AveragePooling2D(pool_size=8)(x)
297 |     y = keras.layers.Flatten()(x)
298 |     if bayesian:
299 |         # scale the KL divergence function to avoid the loss function being over-regularized
300 |         dense = tfp.layers.DenseFlipout(n_class,
301 |                                         activation=None,
302 |                                         kernel_posterior_fn=get_kernel_posterior_fn(),
303 |                                         kernel_divergence_fn=None)
304 |         w = dense.add_weight(name=dense.name+'/kl_loss_weight', shape=(), initializer=tf.initializers.constant(0.0), trainable=False)
305 |         dense.kernel_divergence_fn = get_kernel_divergence_fn(train_size, w)
306 |         logits = dense(y)
307 |     else:
308 |         logits = keras.layers.Dense(n_class,
309 |                                     activation=None,
310 |                                     kernel_initializer='he_normal')(y)
311 |     # Instantiate model.
312 |     model = keras.Model(inputs=inputs, outputs=logits)
313 | 
314 |     return model
315 | 
316 | 
317 | def resnet_v2(input_shape, n_res_block, train_size, n_class=10, bayesian=False):
318 |     """ResNet Version 2 Model builder [b]
319 | 
320 |     Stacks of (1 x 1)-(3 x 3)-(1 x 1) BN-ReLU-Conv2D or also known as
321 |     bottleneck layer
322 |     First shortcut connection per layer is 1 x 1 Conv2D.
323 |     Second and onwards shortcut connection is identity.
324 |     At the beginning of each stage, the feature map size is halved (downsampled)
325 |     by a convolutional layer with strides=2, while the number of filter maps is
326 |     doubled. Within each stage, the layers have the same number filters and the
327 |     same filter map sizes.
328 |     Features maps sizes:
329 |     conv1  : 32x32,  16
330 |     stage 0: 32x32,  64
331 |     stage 1: 16x16, 128
332 |     stage 2:  8x8,  256
333 | 
334 |     # Arguments
335 |         input_shape (tensor): shape of input image tensor
336 |         n_res_block (int): number of residual blocks
337 |         n_class (int): number of classes (CIFAR10 has 10)
338 |         bayesian (bool): implement Bayesian neural network (True) or point-estimate neural network (False)
339 | 
340 |     # Returns
341 |         model (Model): Keras model instance
342 |     """
343 |     n_filter_in = 16
344 | 
345 |     inputs = keras.layers.Input(shape=input_shape)
346 |     # v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths
347 |     x = resnet_layer(inputs=inputs, train_size=train_size,
348 |                      n_filter=n_filter_in,
349 |                      conv_first=True,
350 |                      bayesian=bayesian)
351 | 
352 |     # Instantiate the stack of residual units
353 |     for stage in range(3):
354 |         for res_block in range(n_res_block):
355 |             activation = 'relu'
356 |             batch_normalization = True
357 |             strides = 1
358 |             if stage == 0:
359 |                 n_filter_out = n_filter_in * 4
360 |                 if res_block == 0:  # first layer and first stage
361 |                     activation = None
362 |                     batch_normalization = False
363 |             else:
364 |                 n_filter_out = n_filter_in * 2
365 |                 if res_block == 0:  # first layer but not first stage
366 |                     strides = 2  # downsample
367 | 
368 |             # bottleneck residual unit
369 |             y = resnet_layer(inputs=x, train_size=train_size,
370 |                              n_filter=n_filter_in,
371 |                              kernel_size=1,
372 |                              strides=strides,
373 |                              activation=activation,
374 |                              batch_normalization=batch_normalization,
375 |                              conv_first=False,
376 |                              bayesian=bayesian)
377 |             y = resnet_layer(inputs=y, train_size=train_size,
378 |                              n_filter=n_filter_in,
379 |                              conv_first=False,
380 |                              bayesian=bayesian)
381 |             y = resnet_layer(inputs=y, train_size=train_size,
382 |                              n_filter=n_filter_out,
383 |                              kernel_size=1,
384 |                              conv_first=False,
385 |                              bayesian=bayesian)
386 |             if res_block == 0:
387 |                 # linear projection residual shortcut connection to match
388 |                 # changed dims
389 |                 x = resnet_layer(inputs=x, train_size=train_size,
390 |                                  n_filter=n_filter_out,
391 |                                  kernel_size=1,
392 |                                  strides=strides,
393 |                                  activation=None,
394 |                                  batch_normalization=False,
395 |                                  bayesian=bayesian)
396 |             x = keras.layers.add([x, y])
397 | 
398 |         n_filter_in = n_filter_out
399 | 
400 |     # Add classifier on top.
401 |     # v2 has BN-ReLU before Pooling
402 |     x = keras.layers.BatchNormalization()(x)
403 |     x = keras.layers.Activation('relu')(x)
404 |     x = keras.layers.AveragePooling2D(pool_size=8)(x)
405 |     y = keras.layers.Flatten()(x)
406 |     if bayesian:
407 |         # scale the KL divergence function to avoid the loss function being over-regularized
408 |         dense = tfp.layers.DenseFlipout(n_class,
409 |                                         activation=None,
410 |                                         kernel_posterior_fn=get_kernel_posterior_fn(),
411 |                                         kernel_divergence_fn=None)
412 |         w = dense.add_weight(name=dense.name+'/kl_loss_weight', shape=(), initializer=tf.initializers.constant(0.0), trainable=False)
413 |         dense.kernel_divergence_fn = get_kernel_divergence_fn(train_size, w)
414 |         logits = dense(y)
415 |     else:
416 |         logits = keras.layers.Dense(n_class,
417 |                                     activation=None,
418 |                                     kernel_initializer='he_normal')(y)
419 |     # Instantiate model.
420 |     model = keras.Model(inputs=inputs, outputs=logits)
421 | 
422 |     return model
423 | 
424 | 
425 | if __name__ == '__main__':
426 | 
427 |     # Bayesian mode setting
428 |     bayesian = True
429 |     if bayesian:
430 |         keras = tf.keras
431 | 
432 |     n_mc_run = 20 if bayesian else 1
433 | 
434 |     # Training parameters
435 |     batch_size = 128  # orig paper trained all networks with batch_size=128
436 |     epochs = 200
437 |     data_augmentation = False
438 |     n_class = 10
439 | 
440 |     # Subtracting pixel mean improves accuracy
441 |     subtract_pixel_mean = True
442 | 
443 |     n_res_block = 3
444 | 
445 |     # Model version
446 |     # Orig paper: version = 1 (ResNet v1), Improved ResNet: version = 2 (ResNet v2)
447 |     version = 2
448 |     assert version in [1, 2], 'ResNet version must be 1 or 2.'
449 | 
450 |     # Computed depth from supplied model parameter n_res_block
451 |     depth = n_res_block * 6 + 2 if version == 1 else n_res_block * 9 + 2
452 | 
453 |     # Model name, depth and version
454 |     model_type = 'ResNet%dv%d' % (depth, version)
455 |     if bayesian:
456 |         model_type += '_Bayesian'
457 | 
458 |     # Load the CIFAR10 data.
459 |     (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
460 | 
461 |     # Input image dimensions.
462 |     input_shape = x_train.shape[1:]
463 | 
464 |     # Normalize data.
465 |     x_train = x_train.astype('float32') / 255
466 |     x_test = x_test.astype('float32') / 255
467 | 
468 |     # If subtract pixel mean is enabled
469 |     if subtract_pixel_mean:
470 |         x_train_mean = np.mean(x_train, axis=0)
471 |         x_train -= x_train_mean
472 |         x_test -= x_train_mean
473 | 
474 |     print('x_train shape:', x_train.shape)
475 |     print(x_train.shape[0], 'train samples')
476 |     print(x_test.shape[0], 'test samples')
477 |     print('y_train shape:', y_train.shape)
478 | 
479 |     # Convert class vectors to binary class matrices.
480 |     y_train = keras.utils.to_categorical(y_train, n_class)
481 |     y_test = keras.utils.to_categorical(y_test, n_class)
482 | 
483 |     if version == 1:
484 |         model = resnet_v1(input_shape=input_shape,
485 |                           n_res_block=n_res_block,
486 |                           train_size=len(x_train),
487 |                           bayesian=bayesian)
488 |     else:
489 |         model = resnet_v2(input_shape=input_shape,
490 |                           n_res_block=n_res_block,
491 |                           train_size=len(x_train),
492 |                           bayesian=bayesian)
493 | 
494 |     model.compile(loss=get_neg_log_likelihood_fn(bayesian=bayesian),
495 |                   optimizer=keras.optimizers.Adam(lr=lr_schedule(0)),
496 |                   metrics=[get_categorical_accuracy_fn])
497 |     model.summary()
498 |     print(model_type)
499 | 
500 |     # Prepare model model saving directory.
501 |     save_dir = os.path.join(os.getcwd(), 'saved_models')
502 |     model_vis_name = 'cifar10_%s_model.png' % model_type
503 |     model_name = 'cifar10_%s_model.h5' % model_type
504 |     if not os.path.isdir(save_dir):
505 |         os.makedirs(save_dir)
506 |     model_vis_filepath = os.path.join(save_dir, model_vis_name)
507 |     model_filepath = os.path.join(save_dir, model_name)
508 | 
509 |     # Plot the model
510 |     keras.utils.plot_model(model, to_file=model_vis_filepath, show_shapes=True)
511 | 
512 |     # Prepare callbacks for model saving and for learning rate adjustment.
513 |     checkpoint = keras.callbacks.ModelCheckpoint(filepath=model_filepath,
514 |                                                  monitor='val_get_categorical_accuracy_fn',
515 |                                                  verbose=1,
516 |                                                  save_best_only=True,
517 |                                                  save_weights_only=True)
518 | 
519 |     lr_scheduler = keras.callbacks.LearningRateScheduler(lr_schedule)
520 | 
521 |     lr_reducer = keras.callbacks.ReduceLROnPlateau(factor=np.sqrt(0.1),
522 |                                                    cooldown=0,
523 |                                                    patience=5,
524 |                                                    min_lr=0.5e-6)
525 | 
526 |     callbacks = [checkpoint, lr_reducer, lr_scheduler]
527 |     if bayesian:
528 |         kl_loss_scheduler = KLLossScheduler(update_per_batch=True)
529 |         callbacks += [kl_loss_scheduler]
530 | 
531 |     # Run training, with or without data augmentation.
532 |     if not os.path.isfile(model_filepath):
533 |         if not data_augmentation:
534 |             print('Not using data augmentation.')
535 |             model.fit(x_train, y_train,
536 |                       batch_size=batch_size,
537 |                       epochs=epochs,
538 |                       validation_data=(x_test, y_test),
539 |                       shuffle=True,
540 |                       callbacks=callbacks)
541 |         else:
542 |             print('Using real-time data augmentation.')
543 |             # This will do preprocessing and realtime data augmentation:
544 |             datagen = keras.preprocessing.image.ImageDataGenerator(
545 |                 # set input mean to 0 over the dataset
546 |                 featurewise_center=False,
547 |                 # set each sample mean to 0
548 |                 samplewise_center=False,
549 |                 # divide inputs by std of dataset
550 |                 featurewise_std_normalization=False,
551 |                 # divide each input by its std
552 |                 samplewise_std_normalization=False,
553 |                 # apply ZCA whitening
554 |                 zca_whitening=False,
555 |                 # epsilon for ZCA whitening
556 |                 zca_epsilon=1e-06,
557 |                 # randomly rotate images in the range (deg 0 to 180)
558 |                 rotation_range=0,
559 |                 # randomly shift images horizontally
560 |                 width_shift_range=0.1,
561 |                 # randomly shift images vertically
562 |                 height_shift_range=0.1,
563 |                 # set range for random shear
564 |                 shear_range=0.,
565 |                 # set range for random zoom
566 |                 zoom_range=0.,
567 |                 # set range for random channel shifts
568 |                 channel_shift_range=0.,
569 |                 # set mode for filling points outside the input boundaries
570 |                 fill_mode='nearest',
571 |                 # value used for fill_mode = "constant"
572 |                 cval=0.,
573 |                 # randomly flip images
574 |                 horizontal_flip=True,
575 |                 # randomly flip images
576 |                 vertical_flip=False,
577 |                 # set rescaling factor (applied before any other transformation)
578 |                 rescale=None,
579 |                 # set function that will be applied on each input
580 |                 preprocessing_function=None,
581 |                 # image data format, either "channels_first" or "channels_last"
582 |                 data_format=None,
583 |                 # fraction of images reserved for validation (strictly between 0 and 1)
584 |                 validation_split=0.0)
585 | 
586 |             # Compute quantities required for featurewise normalization
587 |             # (std, mean, and principal components if ZCA whitening is applied).
588 |             datagen.fit(x_train)
589 | 
590 |             # Fit the model on the batches generated by datagen.flow().
591 |             model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
592 |                                 steps_per_epoch=len(x_train) / batch_size,
593 |                                 validation_data=(x_test, y_test),
594 |                                 epochs=epochs, verbose=1, workers=4,
595 |                                 callbacks=callbacks)
596 |     model.load_weights(model_filepath)  # load the optimal model with the lowest validation loss
597 | 
598 |     # apply the model on test data
599 |     y_pred_logits = [model.predict(x_test) for _ in range(n_mc_run)]
600 |     y_pred_logits = np.concatenate([y[np.newaxis, :, :] for y in y_pred_logits], axis=0)
601 |     y_pred_logits_mean = np.mean(y_pred_logits, axis=0)
602 |     y_pred_logits_std = np.std(y_pred_logits, axis=0)
603 | 
604 |     y_pred_softmax = keras.layers.Activation('softmax')(keras.backend.variable(y_pred_logits_mean)).eval(session=keras.backend.get_session())
605 |     print('Test accuracy: ', sum(np.equal(np.argmax(y_test, axis=-1), np.argmax(y_pred_softmax, axis=-1))) / len(y_test))


--------------------------------------------------------------------------------
/tfp_bgmm_MultivariateNormalTriL_MCMC.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Bayesian Gaussian Mixture Modeling using TensorFlow Probability"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "code",
 12 |    "execution_count": 1,
 13 |    "metadata": {},
 14 |    "outputs": [
 15 |     {
 16 |      "name": "stdout",
 17 |      "output_type": "stream",
 18 |      "text": [
 19 |       "TensorFlow version: 2.1.0-dev20191015\n",
 20 |       "TensorFlow Probability version: 0.9.0-dev20191016\n"
 21 |      ]
 22 |     }
 23 |    ],
 24 |    "source": [
 25 |     "import tensorflow as tf\n",
 26 |     "import tensorflow_probability as tfp\n",
 27 |     "tfb = tfp.bijectors\n",
 28 |     "tfd = tfp.distributions\n",
 29 |     "tf.compat.v1.disable_eager_execution()  # Eager execution is disabled as it significantly slows down MCMC\n",
 30 |     "\n",
 31 |     "import sys\n",
 32 |     "import time\n",
 33 |     "import functools\n",
 34 |     "import numpy as np\n",
 35 |     "import pandas as pd\n",
 36 |     "import seaborn as sns\n",
 37 |     "import matplotlib.pyplot as plt\n",
 38 |     "from mpl_toolkits.mplot3d import Axes3D\n",
 39 |     "from operator import mul\n",
 40 |     "from sklearn.cluster import KMeans\n",
 41 |     "\n",
 42 |     "%matplotlib inline\n",
 43 |     "\n",
 44 |     "print('TensorFlow version:', tf.__version__)\n",
 45 |     "print('TensorFlow Probability version:', tfp.__version__)"
 46 |    ]
 47 |   },
 48 |   {
 49 |    "cell_type": "code",
 50 |    "execution_count": 2,
 51 |    "metadata": {},
 52 |    "outputs": [
 53 |     {
 54 |      "name": "stdout",
 55 |      "output_type": "stream",
 56 |      "text": [
 57 |       "Device mapping:\n",
 58 |       "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: Quadro P1000, pci bus id: 0000:01:00.0, compute capability: 6.1\n",
 59 |       "\n"
 60 |      ]
 61 |     }
 62 |    ],
 63 |    "source": [
 64 |     "def session_options(enable_gpu_ram_resizing=True):\n",
 65 |     "    \"\"\"Convenience function which sets common `tf.Session` options.\"\"\"\n",
 66 |     "    config = tf.compat.v1.ConfigProto()\n",
 67 |     "    config.log_device_placement = True\n",
 68 |     "    if enable_gpu_ram_resizing:\n",
 69 |     "        # `allow_growth=True` makes it possible to connect multiple colabs to your\n",
 70 |     "        # GPU. Otherwise the colab malloc's all GPU ram.\n",
 71 |     "        config.gpu_options.allow_growth = True\n",
 72 |     "    return config\n",
 73 |     "\n",
 74 |     "def reset_sess(config=None):\n",
 75 |     "    \"\"\"Convenience function to create the TF graph and session, or reset them.\"\"\"\n",
 76 |     "    if config is None:\n",
 77 |     "        config = session_options()\n",
 78 |     "    tf.compat.v1.reset_default_graph()\n",
 79 |     "    global sess\n",
 80 |     "    try:\n",
 81 |     "        sess.close()\n",
 82 |     "    except:\n",
 83 |     "        pass\n",
 84 |     "    sess = tf.compat.v1.InteractiveSession(config=config)\n",
 85 |     "\n",
 86 |     "reset_sess()"
 87 |    ]
 88 |   },
 89 |   {
 90 |    "cell_type": "markdown",
 91 |    "metadata": {},
 92 |    "source": [
 93 |     "## Generate some data"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 3,
 99 |    "metadata": {},
100 |    "outputs": [
101 |     {
102 |      "data": {
103 |       "image/png": "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\n",
104 |       "text/plain": [
105 |        "<Figure size 720x720 with 1 Axes>"
106 |       ]
107 |      },
108 |      "metadata": {
109 |       "needs_background": "light"
110 |      },
111 |      "output_type": "display_data"
112 |     }
113 |    ],
114 |    "source": [
115 |     "eps = 1e-6\n",
116 |     "\n",
117 |     "n_samples_per_component = 1000\n",
118 |     "n_dims = 3\n",
119 |     "X = []\n",
120 |     "X.append(np.random.multivariate_normal([5, 5, 0],\n",
121 |     "                                       [[0.1, 0, 0], [0, 1, 0.6], [0, 0.6, 2]],\n",
122 |     "                                       n_samples_per_component).astype('float64'))\n",
123 |     "X.append(np.random.multivariate_normal([-5, -5, 0],\n",
124 |     "                                       [[0.1, 0, 0], [0, 1, 0.6], [0, 0.6, 2]],\n",
125 |     "                                       n_samples_per_component).astype('float64'))\n",
126 |     "X.append(np.random.multivariate_normal([0, 5, 5],\n",
127 |     "                                       [[1, 0.6, 0], [0.6, 1, 0], [0, 0, 0.2]],\n",
128 |     "                                       n_samples_per_component).astype('float64'))\n",
129 |     "X.append(np.random.multivariate_normal([0, -5, -5],\n",
130 |     "                                       [[1, 0.6, 0], [0.6, 1, 0], [0, 0, 0.2]],\n",
131 |     "                                       n_samples_per_component).astype('float64'))\n",
132 |     "n_components = len(X)\n",
133 |     "n_samples = n_samples_per_component * n_components\n",
134 |     "X = np.concatenate(X)\n",
135 |     "\n",
136 |     "# Plot the data\n",
137 |     "fig = plt.figure(figsize=(10, 10))\n",
138 |     "ax = plt.axes(projection='3d')\n",
139 |     "ax.scatter(X[:, 0], X[:, 1], X[:, 2], marker='.')\n",
140 |     "ax.set_xlabel('$x_0$')\n",
141 |     "ax.set_ylabel('$x_1$')\n",
142 |     "ax.set_zlabel('$x_2$')\n",
143 |     "plt.show()"
144 |    ]
145 |   },
146 |   {
147 |    "cell_type": "markdown",
148 |    "metadata": {},
149 |    "source": [
150 |     "## Build a Gaussian Mixture Model\n",
151 |     "$$\n",
152 |     "\\begin{aligned}\n",
153 |     "\\mathbf{x}_n &\\sim \\sum\\limits_k \\pi_k \\mathcal{N}\\left(\\pmb{\\mu_x}_k, \\pmb{\\Sigma_x}_k\\right)\\\\\n",
154 |     "\\pi_k &\\sim \\mathcal{D}\\left(K, \\mathbf{c}\\right)\\\\\n",
155 |     "\\forall k \\quad&\\left\\{\n",
156 |     "    \\begin{aligned}\n",
157 |     "    \\pmb{\\Sigma_x}_k^{-1} &\\sim \\mathcal{W}\\left(\\mathbf{W}, \\nu\\right)\\\\\n",
158 |     "    \\pmb{\\mu_x}_k &\\sim \\mathcal{N}\\left(\\pmb{\\mu_0}, \\pmb{\\Sigma_0}\\right)\n",
159 |     "    \\end{aligned}\n",
160 |     "\\right.\n",
161 |     "\\end{aligned}\n",
162 |     "$$"
163 |    ]
164 |   },
165 |   {
166 |    "cell_type": "markdown",
167 |    "metadata": {},
168 |    "source": [
169 |     "### prior distributions"
170 |    ]
171 |   },
172 |   {
173 |    "cell_type": "code",
174 |    "execution_count": 4,
175 |    "metadata": {},
176 |    "outputs": [
177 |     {
178 |      "name": "stdout",
179 |      "output_type": "stream",
180 |      "text": [
181 |       "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\nightly\\lib\\site-packages\\tensorflow_core\\python\\ops\\linalg\\linear_operator_lower_triangular.py:158: calling LinearOperator.__init__ (from tensorflow.python.ops.linalg.linear_operator) with graph_parents is deprecated and will be removed in a future version.\n",
182 |       "Instructions for updating:\n",
183 |       "Do not pass `graph_parents`.  They will  no longer be used.\n"
184 |      ]
185 |     }
186 |    ],
187 |    "source": [
188 |     "theta_prior = tfd.Dirichlet(\n",
189 |     "    concentration=2 * np.ones(n_components, dtype=np.float64), name='theta_prior',\n",
190 |     "    validate_args=True, allow_nan_stats=False)\n",
191 |     "\n",
192 |     "mu_prior = tfd.Independent(\n",
193 |     "    tfd.Normal(loc=np.stack([np.zeros(n_dims, dtype=np.float64)] * n_components),\n",
194 |     "               scale=tf.ones((n_components, n_dims), dtype=np.float64),\n",
195 |     "               validate_args=True, allow_nan_stats=False),\n",
196 |     "    reinterpreted_batch_ndims=1,\n",
197 |     "    name='mu_prior',\n",
198 |     "    validate_args=True)\n",
199 |     "\n",
200 |     "invcov_chol_prior = tfd.WishartTriL(df=n_dims+2,\n",
201 |     "                                    scale_tril=np.stack([np.eye(n_dims, dtype=np.float64)] * n_components),\n",
202 |     "                                    input_output_cholesky=True,\n",
203 |     "                                    name='invcov_chol_prior',\n",
204 |     "                                    validate_args=True, allow_nan_stats=False)"
205 |    ]
206 |   },
207 |   {
208 |    "cell_type": "markdown",
209 |    "metadata": {},
210 |    "source": [
211 |     "### joint log probability"
212 |    ]
213 |   },
214 |   {
215 |    "cell_type": "code",
216 |    "execution_count": 5,
217 |    "metadata": {},
218 |    "outputs": [],
219 |    "source": [
220 |     "def joint_log_prob(x, theta, mu, invcov_chol):\n",
221 |     "    \"\"\"BGMM with priors: theta=Dirichlet, mu=Normal, invcov_chol=Wishart\n",
222 |     "\n",
223 |     "    Args:\n",
224 |     "    x: `[n, d]`-shaped `Tensor` representing Bayesian Gaussian Mixture model draws.\n",
225 |     "       Each sample is a length-`d` vector.\n",
226 |     "    theta: `[K]`-shaped `Tensor` representing random draw from `SoftmaxInverse(Dirichlet)` prior.\n",
227 |     "    mu: `[K, d]`-shaped `Tensor` representing the location parameter of the `K` components.\n",
228 |     "    invcov_chol: `[K, d, d]`-shaped `Tensor` representing `K` lower triangular `cholesky(Precision)` matrices,\n",
229 |     "                 each being sampled from a Wishart distribution.\n",
230 |     "\n",
231 |     "    Returns:\n",
232 |     "    log_prob: `Tensor` representing joint log-density over all inputs.\n",
233 |     "    \"\"\"\n",
234 |     "    cov = tf.linalg.inv(tf.matmul(invcov_chol, tf.linalg.matrix_transpose(invcov_chol)))\n",
235 |     "\n",
236 |     "    gmm = tfd.MixtureSameFamily(\n",
237 |     "        mixture_distribution=tfd.Categorical(probs=theta),\n",
238 |     "        components_distribution=tfd.MultivariateNormalTriL(loc=mu,\n",
239 |     "                                                           scale_tril=tf.linalg.cholesky(cov)))\n",
240 |     "    log_prob_parts = [\n",
241 |     "        gmm.log_prob(x),  # log probabilities (summed to be log-likelihoods)\n",
242 |     "        theta_prior.log_prob(theta)[..., tf.newaxis],  # prior probabilities of theta\n",
243 |     "        mu_prior.log_prob(mu),  # prior probabilities of mu\n",
244 |     "        invcov_chol_prior.log_prob(invcov_chol)  # prior probabilities of invcov_chol\n",
245 |     "    ]\n",
246 |     "    sum_log_prob = tf.reduce_sum(tf.concat(log_prob_parts, axis=-1), axis=-1)  # joint log probabilities\n",
247 |     "    return sum_log_prob"
248 |    ]
249 |   },
250 |   {
251 |    "cell_type": "markdown",
252 |    "metadata": {},
253 |    "source": [
254 |     "## Bayesian Inference using Markov chain Monte Carlo (MCMC) algorithms"
255 |    ]
256 |   },
257 |   {
258 |    "cell_type": "code",
259 |    "execution_count": 6,
260 |    "metadata": {},
261 |    "outputs": [],
262 |    "source": [
263 |     "unnormalized_posterior_log_prob = functools.partial(joint_log_prob, X)"
264 |    ]
265 |   },
266 |   {
267 |    "cell_type": "markdown",
268 |    "metadata": {},
269 |    "source": [
270 |     "### set up initial states"
271 |    ]
272 |   },
273 |   {
274 |    "cell_type": "code",
275 |    "execution_count": 7,
276 |    "metadata": {},
277 |    "outputs": [],
278 |    "source": [
279 |     "initial_state = [\n",
280 |     "    (1 / n_components) * tf.ones(n_components, dtype=tf.float64, name='theta'),\n",
281 |     "    tf.convert_to_tensor(np.array([[5, 5, 0],\n",
282 |     "                                   [-5, -5, 0],\n",
283 |     "                                   [0, 5, 5],\n",
284 |     "                                   [0, -5, -5]], dtype=np.float64),\n",
285 |     "                         name='mu'),\n",
286 |     "    tf.linalg.diag(tf.ones((n_components, n_dims), dtype=tf.float64), name='invcov_chol')\n",
287 |     "]"
288 |    ]
289 |   },
290 |   {
291 |    "cell_type": "markdown",
292 |    "metadata": {},
293 |    "source": [
294 |     "### unconstrained representation\n",
295 |     "MCMC requires the target log-probability function be differentiable with respect to its arguments. Furthermore, MCMC can exhibit dramatically higher statistical efficiency if the state-space is unconstrained.\n",
296 |     "\n",
297 |     "To address this requirement we'll need to:\n",
298 |     "\n",
299 |     "1. transform the constrained variables to an unconstrained space;\n",
300 |     "2. run the MCMC in unconstrained space;\n",
301 |     "3. transform the unconstrained variables back to the constrained space."
302 |    ]
303 |   },
304 |   {
305 |    "cell_type": "code",
306 |    "execution_count": 8,
307 |    "metadata": {},
308 |    "outputs": [],
309 |    "source": [
310 |     "# bijectors transforms the unconstrained variables back to the constrained space\n",
311 |     "unconstraining_bijectors = [\n",
312 |     "    tfb.SoftmaxCentered(validate_args=True),  # transform unconstrained theta values to discrete probability vectors\n",
313 |     "    tfb.Identity(validate_args=True),  # identity transformation (no transformation) for mu values\n",
314 |     "    tfb.Chain([\n",
315 |     "        tfb.TransformDiagonal(tfb.Softplus(), validate_args=True),\n",
316 |     "        tfb.FillTriangular(validate_args=True)\n",
317 |     "    ])  # transforms unconstrained invcov_chol values to lower triangular matrices with positive diagonal\n",
318 |     "]"
319 |    ]
320 |   },
321 |   {
322 |    "cell_type": "markdown",
323 |    "metadata": {},
324 |    "source": [
325 |     "### graph for Random Walk Metropolis (RWM) sampling (Method 1)"
326 |    ]
327 |   },
328 |   {
329 |    "cell_type": "code",
330 |    "execution_count": 9,
331 |    "metadata": {},
332 |    "outputs": [
333 |     {
334 |      "name": "stdout",
335 |      "output_type": "stream",
336 |      "text": [
337 |       "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\envs\\nightly\\lib\\site-packages\\tensorflow_probability\\python\\distributions\\mvn_linear_operator.py:193: AffineLinearOperator.__init__ (from tensorflow_probability.python.bijectors.affine_linear_operator) is deprecated and will be removed after 2020-01-01.\n",
338 |       "Instructions for updating:\n",
339 |       "`AffineLinearOperator` bijector is deprecated; please use `tfb.Shift(loc)(tfb.MatvecLinearOperator(...))`.\n"
340 |      ]
341 |     },
342 |     {
343 |      "name": "stderr",
344 |      "output_type": "stream",
345 |      "text": [
346 |       "C:\\ProgramData\\Anaconda3\\envs\\nightly\\lib\\site-packages\\tensorflow_probability\\python\\mcmc\\sample.py:333: UserWarning: Tracing all kernel results by default is deprecated. Set the `trace_fn` argument to None (the future default value) or an explicit callback that traces the values you are interested in.\n",
347 |       "  warnings.warn(\"Tracing all kernel results by default is deprecated. Set \"\n"
348 |      ]
349 |     }
350 |    ],
351 |    "source": [
352 |     "n_results = 16000\n",
353 |     "n_burnin_steps = 8000\n",
354 |     "scale = 1e-3\n",
355 |     "[theta, mu, invcov_chol], kernel_results = tfp.mcmc.sample_chain(num_results=n_results,\n",
356 |     "                                                                 num_burnin_steps=n_burnin_steps,\n",
357 |     "                                                                 current_state=initial_state,\n",
358 |     "                                                                 kernel=tfp.mcmc.TransformedTransitionKernel(\n",
359 |     "                                                                     inner_kernel=tfp.mcmc.RandomWalkMetropolis(\n",
360 |     "                                                                         target_log_prob_fn=unnormalized_posterior_log_prob,\n",
361 |     "                                                                         new_state_fn=tfp.mcmc.random_walk_normal_fn(scale=scale)),\n",
362 |     "                                                                     bijector=unconstraining_bijectors),\n",
363 |     "                                                                 parallel_iterations=100)"
364 |    ]
365 |   },
366 |   {
367 |    "cell_type": "markdown",
368 |    "metadata": {},
369 |    "source": [
370 |     "### launch the graph and display the inferred statistics"
371 |    ]
372 |   },
373 |   {
374 |    "cell_type": "code",
375 |    "execution_count": 10,
376 |    "metadata": {},
377 |    "outputs": [
378 |     {
379 |      "name": "stdout",
380 |      "output_type": "stream",
381 |      "text": [
382 |       "elapsed time: 9595.37s\n",
383 |       "acceptance_rate: 0.862625\n",
384 |       "avg mix probs: [0.24844049 0.25512503 0.24762867 0.24880581]\n",
385 |       "\n",
386 |       "avg loc:\n",
387 |       " [[ 4.99136968  5.02519328  0.12765716]\n",
388 |       " [-4.98041703 -4.97772828 -0.0572409 ]\n",
389 |       " [ 0.00996063  5.02680586  5.00870718]\n",
390 |       " [-0.0314585  -4.98221856 -4.99639094]]\n",
391 |       "\n",
392 |       "avg precision cholesky:\n",
393 |       " [[[ 2.47709883  0.          0.        ]\n",
394 |       "  [ 0.05957447  1.10980288  0.        ]\n",
395 |       "  [-0.01921852 -0.35457543  0.70271206]]\n",
396 |       "\n",
397 |       " [[ 2.46778401  0.          0.        ]\n",
398 |       "  [-0.0616935   1.0843033   0.        ]\n",
399 |       "  [ 0.00980305 -0.31878146  0.69907693]]\n",
400 |       "\n",
401 |       " [[ 1.23256135  0.          0.        ]\n",
402 |       "  [-0.67339941  0.97340591  0.        ]\n",
403 |       "  [-0.15097277  0.21016192  2.05898233]]\n",
404 |       "\n",
405 |       " [[ 1.25751358  0.          0.        ]\n",
406 |       "  [-0.76347918  0.99049323  0.        ]\n",
407 |       "  [-0.10465556 -0.03029713  2.09267267]]]\n",
408 |       "\n",
409 |       "avg covariance matrix:\n",
410 |       " [[[ 1.65442030e-01 -1.91825730e-02 -3.96328617e-05]\n",
411 |       "  [-1.91825730e-02  1.01935527e+00  6.47246881e-01]\n",
412 |       "  [-3.96328617e-05  6.47246881e-01  2.02602839e+00]]\n",
413 |       "\n",
414 |       " [[ 1.66775947e-01  2.28697436e-02  6.58647346e-03]\n",
415 |       "  [ 2.28697436e-02  1.02893153e+00  6.01939233e-01]\n",
416 |       "  [ 6.58647346e-03  6.01939233e-01  2.04737284e+00]]\n",
417 |       "\n",
418 |       " [[ 9.74369775e-01  5.76760515e-01  1.29443252e-03]\n",
419 |       "  [ 5.76760515e-01  1.06695074e+00 -5.08535367e-02]\n",
420 |       "  [ 1.29443252e-03 -5.08535367e-02  2.36544302e-01]]\n",
421 |       "\n",
422 |       " [[ 1.01238103e+00  6.21230738e-01  2.36046567e-02]\n",
423 |       "  [ 6.21230738e-01  1.02236233e+00  6.93620343e-03]\n",
424 |       "  [ 2.36046567e-02  6.93620343e-03  2.29015027e-01]]]\n"
425 |      ]
426 |     }
427 |    ],
428 |    "source": [
429 |     "acceptance_rate = tf.reduce_mean(tf.cast(kernel_results.inner_results.is_accepted, tf.float64))\n",
430 |     "\n",
431 |     "theta = theta[n_burnin_steps:]\n",
432 |     "mu = mu[n_burnin_steps:]\n",
433 |     "invcov_chol = invcov_chol[n_burnin_steps:]\n",
434 |     "cov = tf.linalg.inv(tf.matmul(invcov_chol, tf.linalg.matrix_transpose(invcov_chol)))\n",
435 |     "\n",
436 |     "mean_theta = tf.reduce_mean(theta, axis=0)\n",
437 |     "mean_mu = tf.reduce_mean(mu, axis=0)\n",
438 |     "mean_invcov_chol = tf.reduce_mean(invcov_chol, axis=0)\n",
439 |     "mean_cov = tf.reduce_mean(cov, axis=0)\n",
440 |     "\n",
441 |     "start_time = time.time()\n",
442 |     "[val_acceptance_rate, val_mean_theta, val_mean_mu, val_mean_invcov_chol, val_mean_cov] = sess.run(\n",
443 |     "    [acceptance_rate, mean_theta, mean_mu, mean_invcov_chol, mean_cov])\n",
444 |     "elapsed_time = time.time() - start_time\n",
445 |     "print('elapsed time: {:.2f}s'.format(elapsed_time))\n",
446 |     "\n",
447 |     "print('acceptance_rate:', val_acceptance_rate)\n",
448 |     "print('avg mix probs:', val_mean_theta)\n",
449 |     "print('\\navg loc:\\n', val_mean_mu)\n",
450 |     "print('\\navg precision cholesky:\\n', val_mean_invcov_chol)\n",
451 |     "print('\\navg covariance matrix:\\n', val_mean_cov)"
452 |    ]
453 |   },
454 |   {
455 |    "cell_type": "markdown",
456 |    "metadata": {},
457 |    "source": [
458 |     "### graph for Hamiltonian Monte Carlo (HMC) sampling (Method 2)"
459 |    ]
460 |   },
461 |   {
462 |    "cell_type": "code",
463 |    "execution_count": 11,
464 |    "metadata": {},
465 |    "outputs": [
466 |     {
467 |      "name": "stderr",
468 |      "output_type": "stream",
469 |      "text": [
470 |       "C:\\ProgramData\\Anaconda3\\envs\\nightly\\lib\\site-packages\\tensorflow_probability\\python\\mcmc\\sample.py:333: UserWarning: Tracing all kernel results by default is deprecated. Set the `trace_fn` argument to None (the future default value) or an explicit callback that traces the values you are interested in.\n",
471 |       "  warnings.warn(\"Tracing all kernel results by default is deprecated. Set \"\n"
472 |      ]
473 |     }
474 |    ],
475 |    "source": [
476 |     "n_results = 4000\n",
477 |     "n_burnin_steps = 2000\n",
478 |     "step_size = 1e-2\n",
479 |     "num_leapfrog_steps = 10\n",
480 |     "[theta, mu, invcov_chol], kernel_results = tfp.mcmc.sample_chain(num_results=n_results,\n",
481 |     "                                                                 num_burnin_steps=n_burnin_steps,\n",
482 |     "                                                                 current_state=initial_state,\n",
483 |     "                                                                 kernel=tfp.mcmc.TransformedTransitionKernel(\n",
484 |     "                                                                     inner_kernel=tfp.mcmc.HamiltonianMonteCarlo(\n",
485 |     "                                                                         target_log_prob_fn=unnormalized_posterior_log_prob,\n",
486 |     "                                                                         step_size=step_size,\n",
487 |     "                                                                         num_leapfrog_steps=num_leapfrog_steps),\n",
488 |     "                                                                     bijector=unconstraining_bijectors),\n",
489 |     "                                                                 parallel_iterations=100)"
490 |    ]
491 |   },
492 |   {
493 |    "cell_type": "markdown",
494 |    "metadata": {},
495 |    "source": [
496 |     "### launch the graph and display the inferred statistics"
497 |    ]
498 |   },
499 |   {
500 |    "cell_type": "code",
501 |    "execution_count": 12,
502 |    "metadata": {},
503 |    "outputs": [
504 |     {
505 |      "name": "stdout",
506 |      "output_type": "stream",
507 |      "text": [
508 |       "elapsed time: 1529.73s\n",
509 |       "acceptance_rate: 0.87025\n",
510 |       "avg mix probs: [0.2498434  0.25009479 0.25014161 0.2499202 ]\n",
511 |       "\n",
512 |       "avg loc:\n",
513 |       " [[ 4.99109595  5.01778177  0.10850991]\n",
514 |       " [-4.983237   -4.97558152 -0.03743145]\n",
515 |       " [-0.0129128   5.01482     5.00213167]\n",
516 |       " [ 0.02351644 -4.97109919 -5.005098  ]]\n",
517 |       "\n",
518 |       "avg precision cholesky:\n",
519 |       " [[[ 3.06681467  0.          0.        ]\n",
520 |       "  [ 0.07086182  1.1076119   0.        ]\n",
521 |       "  [-0.0261507  -0.34831598  0.70353157]]\n",
522 |       "\n",
523 |       " [[ 3.05631866  0.          0.        ]\n",
524 |       "  [-0.05208389  1.0710462   0.        ]\n",
525 |       "  [ 0.00821412 -0.31225647  0.70647403]]\n",
526 |       "\n",
527 |       " [[ 1.24444161  0.          0.        ]\n",
528 |       "  [-0.74107702  1.01483969  0.        ]\n",
529 |       "  [-0.08706177  0.13554366  2.22257539]]\n",
530 |       "\n",
531 |       " [[ 1.24503975  0.          0.        ]\n",
532 |       "  [-0.7727238   0.9953581   0.        ]\n",
533 |       "  [ 0.01202825 -0.06615687  2.25012359]]]\n",
534 |       "\n",
535 |       "avg covariance matrix:\n",
536 |       " [[[ 1.07148881e-01 -1.80524840e-02  2.55286089e-03]\n",
537 |       "  [-1.80524840e-02  1.01724448e+00  6.36348312e-01]\n",
538 |       "  [ 2.55286089e-03  6.36348312e-01  2.02299863e+00]]\n",
539 |       "\n",
540 |       " [[ 1.07701479e-01  1.62243932e-02  4.59128723e-03]\n",
541 |       "  [ 1.62243932e-02  1.04463059e+00  5.85522613e-01]\n",
542 |       "  [ 4.59128723e-03  5.85522613e-01  2.00849777e+00]]\n",
543 |       "\n",
544 |       " [[ 9.93131442e-01  5.79904979e-01 -1.95259448e-03]\n",
545 |       "  [ 5.79904979e-01  9.77100814e-01 -2.70934357e-02]\n",
546 |       "  [-1.95259448e-03 -2.70934357e-02  2.02742248e-01]]\n",
547 |       "\n",
548 |       " [[ 1.03734163e+00  6.28533826e-01  6.26399375e-03]\n",
549 |       "  [ 6.28533826e-01  1.01304587e+00  1.31660492e-02]\n",
550 |       "  [ 6.26399375e-03  1.31660492e-02  1.97802389e-01]]]\n"
551 |      ]
552 |     }
553 |    ],
554 |    "source": [
555 |     "acceptance_rate = tf.reduce_mean(tf.cast(kernel_results.inner_results.is_accepted, tf.float64))\n",
556 |     "\n",
557 |     "theta = theta[n_burnin_steps:]\n",
558 |     "mu = mu[n_burnin_steps:]\n",
559 |     "invcov_chol = invcov_chol[n_burnin_steps:]\n",
560 |     "cov = tf.linalg.inv(tf.matmul(invcov_chol, tf.linalg.matrix_transpose(invcov_chol)))\n",
561 |     "\n",
562 |     "mean_theta = tf.reduce_mean(theta, axis=0)\n",
563 |     "mean_mu = tf.reduce_mean(mu, axis=0)\n",
564 |     "mean_invcov_chol = tf.reduce_mean(invcov_chol, axis=0)\n",
565 |     "mean_cov = tf.reduce_mean(cov, axis=0)\n",
566 |     "\n",
567 |     "start_time = time.time()\n",
568 |     "[val_acceptance_rate, val_mean_theta, val_mean_mu, val_mean_invcov_chol, val_mean_cov] = sess.run(\n",
569 |     "    [acceptance_rate, mean_theta, mean_mu, mean_invcov_chol, mean_cov])\n",
570 |     "elapsed_time = time.time() - start_time\n",
571 |     "print('elapsed time: {:.2f}s'.format(elapsed_time))\n",
572 |     "\n",
573 |     "print('acceptance_rate:', val_acceptance_rate)\n",
574 |     "print('avg mix probs:', val_mean_theta)\n",
575 |     "print('\\navg loc:\\n', val_mean_mu)\n",
576 |     "print('\\navg precision cholesky:\\n', val_mean_invcov_chol)\n",
577 |     "print('\\navg covariance matrix:\\n', val_mean_cov)"
578 |    ]
579 |   },
580 |   {
581 |    "cell_type": "markdown",
582 |    "metadata": {},
583 |    "source": [
584 |     "### graph for Metropolis-adjusted Langevin algorithm (MALA) sampling (Method 3)"
585 |    ]
586 |   },
587 |   {
588 |    "cell_type": "code",
589 |    "execution_count": 13,
590 |    "metadata": {},
591 |    "outputs": [
592 |     {
593 |      "name": "stderr",
594 |      "output_type": "stream",
595 |      "text": [
596 |       "C:\\ProgramData\\Anaconda3\\envs\\nightly\\lib\\site-packages\\tensorflow_probability\\python\\mcmc\\sample.py:333: UserWarning: Tracing all kernel results by default is deprecated. Set the `trace_fn` argument to None (the future default value) or an explicit callback that traces the values you are interested in.\n",
597 |       "  warnings.warn(\"Tracing all kernel results by default is deprecated. Set \"\n"
598 |      ]
599 |     }
600 |    ],
601 |    "source": [
602 |     "n_results = 4000\n",
603 |     "n_burnin_steps = 2000\n",
604 |     "step_size = 2e-4\n",
605 |     "[theta, mu, invcov_chol], kernel_results = tfp.mcmc.sample_chain(num_results=n_results,\n",
606 |     "                                                                 num_burnin_steps=n_burnin_steps,\n",
607 |     "                                                                 current_state=initial_state,\n",
608 |     "                                                                 kernel=tfp.mcmc.TransformedTransitionKernel(\n",
609 |     "                                                                     inner_kernel=tfp.mcmc.MetropolisAdjustedLangevinAlgorithm(\n",
610 |     "                                                                         target_log_prob_fn=unnormalized_posterior_log_prob,\n",
611 |     "                                                                         step_size=step_size),\n",
612 |     "                                                                     bijector=unconstraining_bijectors),\n",
613 |     "                                                                 parallel_iterations=100)"
614 |    ]
615 |   },
616 |   {
617 |    "cell_type": "markdown",
618 |    "metadata": {},
619 |    "source": [
620 |     "### launch the graph and display the inferred statistics"
621 |    ]
622 |   },
623 |   {
624 |    "cell_type": "code",
625 |    "execution_count": 14,
626 |    "metadata": {},
627 |    "outputs": [
628 |     {
629 |      "name": "stdout",
630 |      "output_type": "stream",
631 |      "text": [
632 |       "elapsed time: 759.22s\n",
633 |       "acceptance_rate: 0.6435\n",
634 |       "avg mix probs: [0.24883278 0.24951683 0.25063191 0.25101848]\n",
635 |       "\n",
636 |       "avg loc:\n",
637 |       " [[ 4.99119668  5.01439659  0.10412371]\n",
638 |       " [-4.98318399 -4.97404597 -0.03899816]\n",
639 |       " [-0.01031765  5.01830767  5.00120453]\n",
640 |       " [ 0.02402447 -4.969517   -5.00546928]]\n",
641 |       "\n",
642 |       "avg precision cholesky:\n",
643 |       " [[[ 3.05036607  0.          0.        ]\n",
644 |       "  [ 0.07515016  1.10424112  0.        ]\n",
645 |       "  [-0.0280067  -0.34487696  0.70550916]]\n",
646 |       "\n",
647 |       " [[ 3.03637912  0.          0.        ]\n",
648 |       "  [-0.06450821  1.07119057  0.        ]\n",
649 |       "  [ 0.01557511 -0.31028529  0.70706238]]\n",
650 |       "\n",
651 |       " [[ 1.25064862  0.          0.        ]\n",
652 |       "  [-0.7510701   1.0170769   0.        ]\n",
653 |       "  [-0.07914385  0.1028017   2.22949531]]\n",
654 |       "\n",
655 |       " [[ 1.24028647  0.          0.        ]\n",
656 |       "  [-0.76607108  0.99803328  0.        ]\n",
657 |       "  [ 0.0452747  -0.02509068  2.24655694]]]\n",
658 |       "\n",
659 |       "avg covariance matrix:\n",
660 |       " [[[ 1.08363041e-01 -1.93511679e-02  2.95535839e-03]\n",
661 |       "  [-1.93511679e-02  1.01813455e+00  6.28355810e-01]\n",
662 |       "  [ 2.95535839e-03  6.28355810e-01  2.01194212e+00]]\n",
663 |       "\n",
664 |       " [[ 1.09282689e-01  1.91413964e-02  2.11489311e-03]\n",
665 |       "  [ 1.91413964e-02  1.04140895e+00  5.80251421e-01]\n",
666 |       "  [ 2.11489311e-03  5.80251421e-01  2.00310135e+00]]\n",
667 |       "\n",
668 |       " [[ 9.90906538e-01  5.81840954e-01  5.75234315e-04]\n",
669 |       "  [ 5.81840954e-01  9.70897765e-01 -2.04146856e-02]\n",
670 |       "  [ 5.75234315e-04 -2.04146856e-02  2.01515665e-01]]\n",
671 |       "\n",
672 |       " [[ 1.03684055e+00  6.21611624e-01 -4.42933867e-03]\n",
673 |       "  [ 6.21611624e-01  1.00620622e+00  4.85717982e-03]\n",
674 |       "  [-4.42933867e-03  4.85717982e-03  1.98521125e-01]]]\n"
675 |      ]
676 |     }
677 |    ],
678 |    "source": [
679 |     "acceptance_rate = tf.reduce_mean(tf.cast(kernel_results.inner_results.is_accepted, tf.float64))\n",
680 |     "\n",
681 |     "theta = theta[n_burnin_steps:]\n",
682 |     "mu = mu[n_burnin_steps:]\n",
683 |     "invcov_chol = invcov_chol[n_burnin_steps:]\n",
684 |     "cov = tf.linalg.inv(tf.matmul(invcov_chol, tf.linalg.matrix_transpose(invcov_chol)))\n",
685 |     "\n",
686 |     "mean_theta = tf.reduce_mean(theta, axis=0)\n",
687 |     "mean_mu = tf.reduce_mean(mu, axis=0)\n",
688 |     "mean_invcov_chol = tf.reduce_mean(invcov_chol, axis=0)\n",
689 |     "mean_cov = tf.reduce_mean(cov, axis=0)\n",
690 |     "\n",
691 |     "start_time = time.time()\n",
692 |     "[val_acceptance_rate, val_mean_theta, val_mean_mu, val_mean_invcov_chol, val_mean_cov] = sess.run(\n",
693 |     "    [acceptance_rate, mean_theta, mean_mu, mean_invcov_chol, mean_cov])\n",
694 |     "elapsed_time = time.time() - start_time\n",
695 |     "print('elapsed time: {:.2f}s'.format(elapsed_time))\n",
696 |     "\n",
697 |     "print('acceptance_rate:', val_acceptance_rate)\n",
698 |     "print('avg mix probs:', val_mean_theta)\n",
699 |     "print('\\navg loc:\\n', val_mean_mu)\n",
700 |     "print('\\navg precision cholesky:\\n', val_mean_invcov_chol)\n",
701 |     "print('\\navg covariance matrix:\\n', val_mean_cov)"
702 |    ]
703 |   }
704 |  ],
705 |  "metadata": {
706 |   "kernelspec": {
707 |    "display_name": "Python 3",
708 |    "language": "python",
709 |    "name": "python3"
710 |   },
711 |   "language_info": {
712 |    "codemirror_mode": {
713 |     "name": "ipython",
714 |     "version": 3
715 |    },
716 |    "file_extension": ".py",
717 |    "mimetype": "text/x-python",
718 |    "name": "python",
719 |    "nbconvert_exporter": "python",
720 |    "pygments_lexer": "ipython3",
721 |    "version": "3.7.3"
722 |   }
723 |  },
724 |  "nbformat": 4,
725 |  "nbformat_minor": 2
726 | }
727 | 


--------------------------------------------------------------------------------