From 4df0ff8917fa1afb7ed1a3b0e10d25383b8d5659 Mon Sep 17 00:00:00 2001 From: Zhenwen Dai Date: Wed, 29 May 2019 20:53:21 +0100 Subject: [PATCH 1/2] Add SVGP regression notebook. --- examples/notebooks/svgp_regression.ipynb | 383 +++++++++++++++++++++++ 1 file changed, 383 insertions(+) create mode 100644 examples/notebooks/svgp_regression.ipynb diff --git a/examples/notebooks/svgp_regression.ipynb b/examples/notebooks/svgp_regression.ipynb new file mode 100644 index 0000000..46f51c1 --- /dev/null +++ b/examples/notebooks/svgp_regression.ipynb @@ -0,0 +1,383 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Stochastic Variational Gaussian Process Regression\n", + "\n", + "**Zhenwen Dai (2019-05-29)**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "Gaussian process (GP) is computationally expensive. A popular approach to scale up GP regression on large data is to use stochastic variational inference with mini-batch training (Hensman et al., 2013). SVGP regression with Gaussian noise has been implemented as a module in MXFusion." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import os\n", + "os.environ['MXNET_ENGINE_TYPE'] = 'NaiveEngine'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Toy data\n", + "\n", + "We generate some synthetic data for our regression example. The data set is generate from a sine function with some additive Gaussian noise. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "%matplotlib inline\n", + "from pylab import *\n", + "\n", + "np.random.seed(0)\n", + "X = np.random.uniform(-3.,3.,(1000,1))\n", + "Y = np.sin(X) + np.random.randn(1000,1)*0.05" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The generated data are visualized as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(X, Y, 'rx', label='data points')\n", + "_=legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from mxfusion.common import config\n", + "config.DEFAULT_DTYPE = 'float64'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The SVGP regression model is created as follow. Two SVGP specific parameters are ```num_inducing``` which specifies the number of inducing points used in the variational sparse GP approximation and ```svgp_log_pdf.jitter``` which the jitter term in the log pdf calculation for numerical robustness. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from mxfusion import Model, Variable\n", + "from mxfusion.components.variables import PositiveTransformation\n", + "from mxfusion.components.distributions.gp.kernels import RBF\n", + "from mxfusion.modules.gp_modules import SVGPRegression\n", + "\n", + "m = Model()\n", + "m.N = Variable()\n", + "m.X = Variable(shape=(m.N, 1))\n", + "m.noise_var = Variable(shape=(1,), transformation=PositiveTransformation(), initial_value=0.01)\n", + "m.kernel = RBF(input_dim=1, variance=1, lengthscale=1)\n", + "m.Y = SVGPRegression.define_variable(X=m.X, kernel=m.kernel, noise_var=m.noise_var, shape=(m.N, 1), num_inducing=20)\n", + "m.Y.factor.svgp_log_pdf.jitter = 1e-6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Inference is done by creating the inference instance from the ```GradBasedInference``` class, in which we use a ```MAP``` inference algorithm as there are no latent variables outside the SVGPRegression module. Additional, we specify ```grad_loop``` to be ```MiniBatchInferenceLoop``` in which we set the size of mini-batch and the scaling factor for minibatch training.\n", + "\n", + "Then, training is triggered by calling the ```run``` method." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 1 Iteration 100 loss: 933115.0603707978\t\t\tepoch-loss: 10413624.614005275 \n", + "epoch 2 Iteration 100 loss: 524948.7079326594\t\t\tepoch-loss: 686034.5295730559 \n", + "epoch 3 Iteration 100 loss: 345602.4022749258\t\t\tepoch-loss: 427065.8343717841 \n", + "epoch 4 Iteration 100 loss: 277011.3760208657\t\t\tepoch-loss: 297071.493696023 \n", + "epoch 5 Iteration 100 loss: 183347.13021907964\t\t\tepoch-loss: 219808.0871498559 \n", + "epoch 6 Iteration 100 loss: 143763.11007552472\t\t\tepoch-loss: 169486.20729875282 \n", + "epoch 7 Iteration 100 loss: 132031.47695326462\t\t\tepoch-loss: 134765.1471133905 \n", + "epoch 8 Iteration 100 loss: 95632.60561449913\t\t\tepoch-loss: 109798.66321648406 \n", + "epoch 9 Iteration 100 loss: 73957.6220462552\t\t\tepoch-loss: 91257.8705670977 \n", + "epoch 10 Iteration 100 loss: 64840.07207031624\t\t\tepoch-loss: 77084.06942481917 \n", + "epoch 11 Iteration 100 loss: 60780.27278575914\t\t\tepoch-loss: 65962.38163622493 \n", + "epoch 12 Iteration 100 loss: 48546.66342698521\t\t\tepoch-loss: 57037.39009905885 \n", + "epoch 13 Iteration 100 loss: 42676.907263579335\t\t\tepoch-loss: 49725.50869601666 \n", + "epoch 14 Iteration 100 loss: 43266.74759690139\t\t\tepoch-loss: 43635.70855486856 \n", + "epoch 15 Iteration 100 loss: 33139.32033870425\t\t\tepoch-loss: 38501.415430223606 \n", + "epoch 16 Iteration 100 loss: 35129.68003531527\t\t\tepoch-loss: 34139.30892930683 \n", + "epoch 17 Iteration 100 loss: 33309.08869286892\t\t\tepoch-loss: 30414.713307491817 \n", + "epoch 18 Iteration 100 loss: 31058.180286752693\t\t\tepoch-loss: 27222.957705478882 \n", + "epoch 19 Iteration 100 loss: 22781.668494776342\t\t\tepoch-loss: 24466.753696665117 \n", + "epoch 20 Iteration 100 loss: 16921.53875526696\t\t\tepoch-loss: 22063.866203795988 \n", + "epoch 21 Iteration 100 loss: 16866.27172281184\t\t\tepoch-loss: 19959.435781693166 \n", + "epoch 22 Iteration 100 loss: 18001.39866328793\t\t\tepoch-loss: 18093.70564938978 \n", + "epoch 23 Iteration 100 loss: 19268.435700542395\t\t\tepoch-loss: 16435.61461383947 \n", + "epoch 24 Iteration 100 loss: 13586.70681551015\t\t\tepoch-loss: 14947.197437326102 \n", + "epoch 25 Iteration 100 loss: 11842.634017398044\t\t\tepoch-loss: 13605.954880888436 \n", + "epoch 26 Iteration 100 loss: 12304.581180033452\t\t\tepoch-loss: 12393.880316263208 \n", + "epoch 27 Iteration 100 loss: 12712.095456995734\t\t\tepoch-loss: 11293.27810727986 \n", + "epoch 28 Iteration 100 loss: 12662.540317512301\t\t\tepoch-loss: 10292.698091923068 \n", + "epoch 29 Iteration 100 loss: 9789.253683769626\t\t\tepoch-loss: 9379.934609293405 \n", + "epoch 30 Iteration 100 loss: 10336.484081253366\t\t\tepoch-loss: 8542.778732654882 \n", + "epoch 31 Iteration 100 loss: 8427.615871046397\t\t\tepoch-loss: 7780.101399774407 \n", + "epoch 32 Iteration 100 loss: 6243.338653452632\t\t\tepoch-loss: 7083.3906599663305 \n", + "epoch 33 Iteration 100 loss: 5633.910939630758\t\t\tepoch-loss: 6442.360608787293 \n", + "epoch 34 Iteration 100 loss: 6128.494674105952\t\t\tepoch-loss: 5856.924952855579 \n", + "epoch 35 Iteration 100 loss: 5561.132651568278\t\t\tepoch-loss: 5319.662670742758 \n", + "epoch 36 Iteration 100 loss: 5007.633559342303\t\t\tepoch-loss: 4827.494923733251 \n", + "epoch 37 Iteration 100 loss: 4570.798941667555\t\t\tepoch-loss: 4375.152951451802 \n", + "epoch 38 Iteration 100 loss: 3427.8776815125993\t\t\tepoch-loss: 3958.746627662967 \n", + "epoch 39 Iteration 100 loss: 3145.271868648371\t\t\tepoch-loss: 3574.2727718396727 \n", + "epoch 40 Iteration 100 loss: 3252.388844355417\t\t\tepoch-loss: 3216.389789008766 \n", + "epoch 41 Iteration 100 loss: 2682.992323506939\t\t\tepoch-loss: 2880.8040627817663 \n", + "epoch 42 Iteration 100 loss: 2776.54316335849\t\t\tepoch-loss: 2563.2893900928902 \n", + "epoch 43 Iteration 100 loss: 2052.181117489573\t\t\tepoch-loss: 2259.124250598867 \n", + "epoch 44 Iteration 100 loss: 1789.3450917418618\t\t\tepoch-loss: 1963.4009524512699 \n", + "epoch 45 Iteration 100 loss: 1637.0460616480382\t\t\tepoch-loss: 1683.301052960261 \n", + "epoch 46 Iteration 100 loss: 1250.3190196168575\t\t\tepoch-loss: 1421.08925599032 \n", + "epoch 47 Iteration 100 loss: 1056.4280170128945\t\t\tepoch-loss: 1181.4882875552755 \n", + "epoch 48 Iteration 100 loss: 934.1323712121834\t\t\tepoch-loss: 972.8920812023131 \n", + "epoch 49 Iteration 100 loss: 743.6854774208032\t\t\tepoch-loss: 794.3919410633861 \n", + "epoch 50 Iteration 100 loss: 592.0162492873271\t\t\tepoch-loss: 643.6129305537779 \n", + "epoch 1 Iteration 100 loss: -617.7115390031664\t\t\tepoch-loss: 122.02590714978953 \n", + "epoch 2 Iteration 100 loss: -1042.9322804366407\t\t\tepoch-loss: -861.8691127743712 \n", + "epoch 3 Iteration 100 loss: -1246.1061590298375\t\t\tepoch-loss: -1142.8551043268158 \n", + "epoch 4 Iteration 100 loss: -1422.4364206976472\t\t\tepoch-loss: -1248.3343954963652 \n", + "epoch 5 Iteration 100 loss: -1364.319275718058\t\t\tepoch-loss: -1319.0632400945233 \n", + "epoch 6 Iteration 100 loss: -1138.6014678286117\t\t\tepoch-loss: -1375.485088640635 \n", + "epoch 7 Iteration 100 loss: -1468.2449906521865\t\t\tepoch-loss: -1415.3387799226973 \n", + "epoch 8 Iteration 100 loss: -1331.0742440765116\t\t\tepoch-loss: -1398.7259993571608 \n", + "epoch 9 Iteration 100 loss: -1023.1218294411456\t\t\tepoch-loss: -1406.2506096944428 \n", + "epoch 10 Iteration 100 loss: -1491.0721525479291\t\t\tepoch-loss: -1425.3786072098467 \n", + "epoch 11 Iteration 100 loss: -1487.9902441406107\t\t\tepoch-loss: -1385.4821177117121 \n", + "epoch 12 Iteration 100 loss: -963.575720938497\t\t\tepoch-loss: -1148.7904243974 \n", + "epoch 13 Iteration 100 loss: -1496.8723348964538\t\t\tepoch-loss: -1248.4710558849933 \n", + "epoch 14 Iteration 100 loss: -1189.2469453417261\t\t\tepoch-loss: -1302.58240646708 \n", + "epoch 15 Iteration 100 loss: -1354.0129933002445\t\t\tepoch-loss: -1422.9290660653176 \n", + "epoch 16 Iteration 100 loss: -1375.0688655561046\t\t\tepoch-loss: -1296.0532055882159 \n", + "epoch 17 Iteration 100 loss: -1601.7368685439442\t\t\tepoch-loss: -1432.8777691683824 \n", + "epoch 18 Iteration 100 loss: -1140.428056593764\t\t\tepoch-loss: -1443.8657069101057 \n", + "epoch 19 Iteration 100 loss: -1396.6869254783921\t\t\tepoch-loss: -1421.0467725977735 \n", + "epoch 20 Iteration 100 loss: -1313.511818206805\t\t\tepoch-loss: -1411.19388568273 \n", + "epoch 21 Iteration 100 loss: -1508.1672406497062\t\t\tepoch-loss: -1427.8889874691674 \n", + "epoch 22 Iteration 100 loss: -1249.1642813846483\t\t\tepoch-loss: -1379.492333117903 \n", + "epoch 23 Iteration 100 loss: -1214.1394062603918\t\t\tepoch-loss: -1356.5797617962307 \n", + "epoch 24 Iteration 100 loss: -1554.6263005956837\t\t\tepoch-loss: -1358.5256191991677 \n", + "epoch 25 Iteration 100 loss: -1419.5889498936215\t\t\tepoch-loss: -1405.5467914984783 \n", + "epoch 26 Iteration 100 loss: -1262.3682620336267\t\t\tepoch-loss: -1409.6484860247688 \n", + "epoch 27 Iteration 100 loss: -1327.4752015434606\t\t\tepoch-loss: -1368.1521038967614 \n", + "epoch 28 Iteration 100 loss: -1256.4414309051297\t\t\tepoch-loss: -1351.3528504368003 \n", + "epoch 29 Iteration 100 loss: -1178.4788588168844\t\t\tepoch-loss: -1413.816013007459 \n", + "epoch 30 Iteration 100 loss: -1605.1239164704423\t\t\tepoch-loss: -1426.6550440932342 \n", + "epoch 31 Iteration 100 loss: -1617.1795697144926\t\t\tepoch-loss: -1356.5267725452202 \n", + "epoch 32 Iteration 100 loss: -1590.7237287842681\t\t\tepoch-loss: -1425.2884165221458 \n", + "epoch 33 Iteration 100 loss: -1594.3448025229204\t\t\tepoch-loss: -1420.5483351285052 \n", + "epoch 34 Iteration 100 loss: -1576.9397677615486\t\t\tepoch-loss: -1430.2946033617723 \n", + "epoch 35 Iteration 100 loss: -1303.3497394593587\t\t\tepoch-loss: -1380.3330104443605 \n", + "epoch 36 Iteration 100 loss: -1478.0145396344049\t\t\tepoch-loss: -1399.0665992260174 \n", + "epoch 37 Iteration 100 loss: -1555.4119456067176\t\t\tepoch-loss: -1360.9939473244767 \n", + "epoch 38 Iteration 100 loss: -1553.031887368961\t\t\tepoch-loss: -1419.1421503464217 \n", + "epoch 39 Iteration 100 loss: -1427.3431059260865\t\t\tepoch-loss: -1415.0248356293594 \n", + "epoch 40 Iteration 100 loss: -1137.8470272897798\t\t\tepoch-loss: -1398.6618957762776 \n", + "epoch 41 Iteration 100 loss: -1551.999240061582\t\t\tepoch-loss: -1402.3061839927834 \n", + "epoch 42 Iteration 100 loss: -1458.4434735943848\t\t\tepoch-loss: -1425.2654433536431 \n", + "epoch 43 Iteration 100 loss: -1585.6542548185487\t\t\tepoch-loss: -1384.815978968837 \n", + "epoch 44 Iteration 100 loss: -1410.7384899311965\t\t\tepoch-loss: -1400.3690408109871 \n", + "epoch 45 Iteration 100 loss: -1343.7557878846794\t\t\tepoch-loss: -1402.4205821010662 \n", + "epoch 46 Iteration 100 loss: -1309.0681838828461\t\t\tepoch-loss: -1412.2783526889364 \n", + "epoch 47 Iteration 100 loss: -1125.0585501913108\t\t\tepoch-loss: -1391.0496208478644 \n", + "epoch 48 Iteration 100 loss: -1470.087468755146\t\t\tepoch-loss: -1390.1175558545679 \n", + "epoch 49 Iteration 100 loss: -1572.597159674086\t\t\tepoch-loss: -1389.4460105298315 \n", + "epoch 50 Iteration 100 loss: -1113.9894360784558\t\t\tepoch-loss: -1403.3841449208112 \n" + ] + } + ], + "source": [ + "import mxnet as mx\n", + "from mxfusion.inference import GradBasedInference, MAP, MinibatchInferenceLoop\n", + "\n", + "infr = GradBasedInference(inference_algorithm=MAP(model=m, observed=[m.X, m.Y]), \n", + " grad_loop=MinibatchInferenceLoop(batch_size=10, rv_scaling={m.Y: 1000/10}))\n", + "infr.initialize(X=(1000,1), Y=(1000,1))\n", + "infr.params[m.Y.factor.inducing_inputs] = mx.nd.array(np.random.randn(20, 1), dtype='float64')\n", + "infr.run(X=mx.nd.array(X, dtype='float64'), Y=mx.nd.array(Y, dtype='float64'), \n", + " max_iter=50, learning_rate=0.1, verbose=True)\n", + "infr.run(X=mx.nd.array(X, dtype='float64'), Y=mx.nd.array(Y, dtype='float64'), \n", + " max_iter=50, learning_rate=0.01, verbose=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The learned kernel parameters are as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The estimated variance of the RBF kernel is 0.220715.\n", + "The estimated length scale of the RBF kernel is 0.498507.\n", + "The estimated variance of the Gaussian likelihood is 0.003107.\n" + ] + } + ], + "source": [ + "print('The estimated variance of the RBF kernel is %f.' % infr.params[m.kernel.variance].asscalar())\n", + "print('The estimated length scale of the RBF kernel is %f.' % infr.params[m.kernel.lengthscale].asscalar())\n", + "print('The estimated variance of the Gaussian likelihood is %f.' % infr.params[m.noise_var].asscalar())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Prediction\n", + "\n", + "The prediction of a SVGP model can be done by creating a ```TransferInference``` instance." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "from mxfusion.inference import TransferInference, ModulePredictionAlgorithm\n", + "infr_pred = TransferInference(ModulePredictionAlgorithm(model=m, observed=[m.X], target_variables=[m.Y]), \n", + " infr_params=infr.params)\n", + "m.Y.factor.svgp_predict.jitter = 1e-6" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize the fitted model, we make predictions on 100 points evenly spanned from -5 to 5. We estimate the mean and variance of the noise-free output $F$." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "xt = np.linspace(-5,5,100)[:, None]\n", + "res = infr_pred.run(X=mx.nd.array(xt, dtype='float64'))[0]\n", + "f_mean, f_var = res[0].asnumpy()[0], res[1].asnumpy()[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting figure is shown as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(xt, f_mean[:,0], 'b-', label='mean')\n", + "plot(xt, f_mean[:,0]-2*np.sqrt(f_var[:, 0]), 'b--', label='2 x std')\n", + "plot(xt, f_mean[:,0]+2*np.sqrt(f_var[:, 0]), 'b--')\n", + "plot(X, Y, 'rx', label='data points')\n", + "ylabel('F')\n", + "xlabel('X')\n", + "_=legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2313c8469b30998893f85bcd234c531dcfaec91a Mon Sep 17 00:00:00 2001 From: Zhenwen Dai Date: Wed, 29 May 2019 20:55:54 +0100 Subject: [PATCH 2/2] Bump the version number. --- mxfusion/__version__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mxfusion/__version__.py b/mxfusion/__version__.py index 8473f95..0a2127a 100644 --- a/mxfusion/__version__.py +++ b/mxfusion/__version__.py @@ -13,4 +13,4 @@ # ============================================================================== -__version__ = '0.3.0' +__version__ = '0.3.1'