{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# SVRGと数値実験\n", "\n", "この章では、NIPS 2013で発表されたstochastic variance reduced gradient (SVRG)という学習アルゴリズムを実装し、それを線形モデルおよび非線形モデルに適用し、そのパフォーマンスをほかのアルゴリズムと比較しつつ、著名なベンチマークデータを用いて検証することを主な目標とする。\n", "\n", "性能評価を行う数値実験は我流ではなく、SVRGを提案した元の論文（*Accelerating Stochastic Gradient Descent using Predictive Variance Reduction*, NIPS 2013, link）での数値実験を模倣するという方針である。\n", "\n", "__目次__\n", "\n", "- アルゴリズムの定式化\n", "\n", "- SVRGの実装\n", "\n", " - 汎用的なSVRG\n", " \n", " - Chainer向けのSVRG\n", "\n", "- 数値実験の概要\n", "\n", "- 学習と性能検証\n", "\n", " - 線形モデル向けの検証（目的関数が凸である）\n", " \n", " - 線形モデル向けの検証（目的関数が非凸である）\n", " \n", " - パフォーマンスの評価\n", "\n", "___" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## アルゴリズムの定式化\n", "\n", "基本的な問題設定をまず述べておく。目的関数は実数値を返す関数の和である。定義域は$\\mathbb{R}^d$である。我々の損失関数の表記を前の章から継承させると、以下のようになる。\n", "\n", "\\begin{align*}\n", "\\min_{w \\in \\mathbb{R}^{d}} F(w), \\quad F(w) = \\frac{1}{n} \\sum_{i=1}^{n} L(w;z_{i}).\n", "\\end{align*}\n", "\n", "この関数を高速に最小化する方法として、確率的勾配降下法(SGD)が有名であることは前の章で述べた通りである。SGDでは、パラメータ空間を探索しながら、全サンプルを使った場合と同じ方向へと平均的に動くが、コストは圧倒的に安いというメリットがある。\n", "\n", "一方、各ステップにおいてSGDがデータセットのごく小さな部分集合しか使わないため、ステップサイズが極限$t \\to \\infty$において$\\alpha_{(t)} \\to 0$でなければ収束しない。サブサンプルを取ることで、SGDの各ステップの更新が、GDを毎回別の目的関数に対して実行することに等しい。永遠に相異なる方向へ引っ張られてしまうから収束しないのである。\n", "\n", "そこで、SVRGを提案した二人の基本的なアイディアは、以下のような折衷案である。\n", "\n", "- ほとんどすべての更新では、ミニバッチの大きさが$B \\ll n$と小さくて、安価である。\n", "\n", "- ごく一部の更新では、全サンプル（$n$個）を使って、正確な勾配ベクトルを計算し、それを以後の更新を安定化させるために何度も再利用する。\n", "\n", "簡明な発想で、容易に実装できる強い学習アルゴリズムである。詳細を見ていこう。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "SVRGの更新則は基本的に2つのループから成る。まずは$\\tilde{w}_{0}$を初期化する。これを「基準ベクトル」として使う。外側のループでは、バッチの全体を使って、この基準ベクトルでの勾配を計算し、内側のループの演算に使う。具体的な算法として、各$s = 1,2,\\ldots$に対して、以下を行う。\n", "\n", "0. $\\tilde{w} = \\tilde{w}_{(s-1)}$\n", "\n", "0. $\\displaystyle \\tilde{g} = \\frac{1}{n} \\sum_{i=1}^{n} \\nabla L(\\tilde{w};z_{i})$\n", "\n", "0. $w_{(0)} = \\tilde{w}$\n", "\n", "0. 内側のループでは$w_{(0)}$を$T$回だけ繰り返して更新し、$w_{(T)}$を返す。\n", "\n", "0. $\\tilde{w}_{s} = w_{(T)}$と置く。\n", "\n", "もっとも重要な計算は$\\tilde{g}$である。最小化したい$F$が$n$個の関数の和であることを考えると、この$\\tilde{g}$はまさに$\\tilde{w}$での理想の更新方向である。$w_{(0)}$の設定は単に内側のループに先立つ初期化である。次は、内側のループの中身を見ていく。各$t=0,1,\\ldots,T$に対して、以下を行う。\n", "\n", "0. 無作為に$I_{t} \\in \\{1,\\ldots,n\\}$をサブサンプル。\n", "0. $\\Delta_{t} = \\nabla L(\\tilde{w};z_{I_{t}}) - \\tilde{g}$\n", "0. 重みベクトルを更新：$\\displaystyle w_{(t+1)} = w_{(t)} - \\alpha \\left(\\nabla L(w_{(t)};z_{I_{t}}) - \\Delta_{t} \\right)$\n", "\n", "このアルゴリズムの設計は実に明瞭である。この$\\Delta_{t}$は、基準ベクトル$\\tilde{w}$に着目し、$n$個のデータ点ではなく、たったの1点を使うことによる「誤差」を次元ごとにまとめたベクトルである。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "言うまでもなく、このアルゴリズムが良い解に至るためには、いくつかの仮定が必要である。特に重要なのは、基準ベクトルを定期的に更新しておけば、$\\tilde{w}$で測った誤差と$w_{(t)}$での本当の誤差がさほど変わらない、ということである。\n", "\n", "あとは、SGDと同様に、$w_{(t)}$を条件として、無作為に選んでいる$I_{t}$について期待値を取ると、以下のようにバッチ全体を使った場合と一致する。\n", "\n", "\\begin{align*}\n", "\\mathbf{E} \\left( \\nabla L(w_{(t)};z_{I_{t}}) - \\Delta_{t} \\right) & = \\frac{1}{n} \\sum_{i=1}^{n} L(w_{(t)};z_{i}) - \\mathbf{E} \\left( \\nabla L(\\tilde{w};z_{I_{t}}) - \\tilde{g}\\right)\\\\\n", "& = \\frac{1}{n} \\sum_{i=1}^{n} L(w_{(t)};z_{i}).\n", "\\end{align*}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## SVRGの実装\n", "\n", "ここで、SVRGを2回実装する。最初は、前の章で紹介した方法論に則って、`Algo_SVRG`という完全なる自作で、`Algo_LineSearch`のサブクラスとして汎用的なものである。その後は、Chainerを前提としたニューラルネットワーク向け実装である。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import math\n", "import numpy as np\n", "import chainer as ch\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "\n", "import algorithms\n", "import models\n", "import models_ch\n", "import dataclass\n", "import helpers as hlp" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 汎用的なSVRG" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class Algo_SVRG(algorithms.Algo_LineSearch):\n", " '''\n", " Stochastic variance reduced gradient descent.\n", " '''\n", " def __init__(self, w_init, step, batchsize, replace,\n", " out_max, in_max, thres, store, lamreg):\n", "\n", " super(Algo_SVRG, self).__init__(w_init=w_init,\n", " step=step,\n", " t_max=(out_max*in_max),\n", " thres=thres,\n", " store=store,\n", " lamreg=lamreg)\n", " self.out_max = out_max\n", " self.in_max = in_max\n", " self.batchsize = batchsize\n", " self.replace = replace\n", "\n", " # Computed internally.\n", " self.nseen = 0\n", " self.npasses = 0\n", " self.idx_inner = 0\n", " self.torecord = True\n", "\n", "\n", " def newdir(self, model, data):\n", " '''\n", " Determine the direction of the update.\n", " '''\n", "\n", " if self.idx_inner == 0:\n", " self.w_snap = np.copy(self.w)\n", " self.g_snap = np.mean(model.g_tr(w=self.w_snap,\n", " data=data,\n", " lamreg=self.lamreg),\n", " axis=0, keepdims=True)\n", " \n", " shufidx = np.random.choice(data.n_tr,\n", " size=self.batchsize,\n", " replace=self.replace)\n", " g_sgd = np.mean(model.g_tr(w=self.w,\n", " n_idx=shufidx,\n", " data=data,\n", " lamreg=self.lamreg),\n", " axis=0, keepdims=True)\n", " correction = np.mean(model.g_tr(w=self.w_snap,\n", " n_idx=shufidx,\n", " data=data,\n", " lamreg=self.lamreg),\n", " axis=0, keepdims=True) - self.g_snap\n", " return (-1) * (g_sgd-correction)\n", "\n", "\n", " def monitor_update(self, model, data):\n", " '''\n", " Update the counters and convergence\n", " monitors used by the algorithm. This is\n", " executed once every step.\n", " '''\n", " self.t += 1\n", " self.idx_inner += 1\n", " if self.idx_inner == self.in_max:\n", " self.idx_inner = 0\n", "\n", " # Check differences every \"epoch\" over data.\n", " self.nseen += self.batchsize\n", " if self.nseen >= data.n_tr:\n", " self.torecord = True\n", " self.npasses += 1\n", " self.diff = np.linalg.norm((self.w-self.w_old))\n", " self.w_old = np.copy(self.w)\n", " self.nseen = self.nseen % data.n_tr\n", " \n", " \n", " def cost_update(self, model, data):\n", " '''\n", " Update the amount of computational resources\n", " used by the routine.\n", "\n", " Cost computation based on number of gradients computed:\n", " - Each inner loop step requires mini-batch gradients for\n", " two vectors, w and w_snap.\n", " - Each outer loop step additionally requires a full\n", " batch of gradients.\n", " '''\n", "\n", " if self.idx_inner == self.in_max:\n", " self.stepcost = 2 * self.batchsize + data.n_tr\n", " else:\n", " self.stepcost = 2 * self.batchsize\n", " \n", " self.cumcost += self.stepcost\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### Chainer向けのSVRG\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "## Experiment setup.\n", "\n", "# Data-related.\n", "data = dataclass.DataSet() # Initialize one data object; will be re-populated at each trial.\n", "n = 500 # sample size\n", "d = 2 # number of parameters\n", "init_delta = 5.0 # controls support of random initialization\n", "num_trials = 250 # number of independent random trials to conduct\n", "cov_X = np.eye(d) # covariance matrix of the inputs.\n", "\n", "w_star = np.ones(d).reshape((d,1)) # vector specifying true model\n", "\n", "# Algorithm-related.\n", "m_idx_todo = [0,1] # let's us manually pick and choose which methods to evaluate.\n", "out_max = 5\n", "batchsize = 1\n", "in_max = 50\n", "t_max = out_max*in_max # termination condition; maximum number of iterations.\n", "thres = -1.0 # termination condition; if negative, runs for max iterations.\n", "\n", "def alpha_fixed(t, val): # step-size callback function.\n", " return val\n", "def make_step(u):\n", " def mystep(t, model=None, data=None, newdir=None):\n", " return alpha_fixed(t=t, val=u)\n", " return mystep\n", "alphaval = 0.05\n", "\n", "# Clerical.\n", "mth_names = [\"svrg\", \"svrg-ch\"]\n", "num_mths = len(mth_names)\n", "mth_colours = [\"black\", \"blue\"]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Make choice of additive noise distribution (un-comment your choice).\n", "#paras = {\"name\": \"norm\", \"shift\": 0.0, \"scale\": 20.0}\n", "paras = {\"name\": \"lnorm\", \"meanlog\": 0.0, \"sdlog\": 1.75}\n", "\n", "# Put together risk function.\n", "def risk(w):\n", " mean_noise, var_noise = hlp.noise_risk(paras=paras)\n", " return hlp.riskMaker(w=w, A=cov_X, b=math.sqrt(var_noise), w_star=w_star)\n", "risk_star = risk(w=w_star) # optimal risk value." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "## Running the algorithms.\n", "\n", "# Prepare storage for performance metrics.\n", "riskvals = np.zeros((num_trials,t_max,num_mths), dtype=np.float32)\n", "loss_tr = np.zeros((num_trials,t_max,num_mths), dtype=np.float32)\n", "truedist = np.zeros((num_trials,t_max,num_mths), dtype=np.float32)\n", "\n", "# Loop over trials.\n", "for tri in range(num_trials):\n", " \n", " # Generate new data (with *centered* noise).\n", " X = np.random.normal(loc=0.0, scale=1.0, size=(n,d))\n", " noise = hlp.noise_data(n=n, paras=paras)\n", " y = np.dot(X, w_star) + noise\n", " data.init_tr(X=X, y=y)\n", " \n", " # Data for Chainer model.\n", " Z = ch.datasets.TupleDataset(np.float32(X),\n", " np.float32(y))\n", " \n", " # Initial weight settings.\n", " w_init = w_star + np.random.uniform(low=-init_delta, high=init_delta, size=d).reshape((d,1))\n", " w_init = np.float32(w_init)\n", " \n", " # Initialize models (hand-built).\n", " mod_learner = models.LinearL2(data=data)\n", " risk_star = risk(w=w_star) # optimal risk value.\n", " loss_star = np.mean(mod_learner.l_tr(w=w_star, data=data))\n", " \n", " # Initialize models (Chainer-based).\n", " mod_chainer = models_ch.MyChain(out_l0=d,\n", " out_l1=1,\n", " init_W=w_init.T,\n", " init_b=None,\n", " init_delta=init_delta,\n", " nobias=True)\n", " \n", " mod_snap = models_ch.MyChain(out_l0=d,\n", " out_l1=1,\n", " init_W=w_init.T,\n", " init_b=None,\n", " init_delta=init_delta,\n", " nobias=True)\n", " \n", " # Initialize algorithms (hand-built).\n", " al_svrg = Algo_SVRG(w_init=w_init,\n", " step=make_step(alphaval),\n", " batchsize=batchsize,\n", " replace=False,\n", " out_max=out_max,\n", " in_max=in_max,\n", " thres=thres,\n", " store=True,\n", " lamreg=None)\n", " \n", " \n", " # Run all algorithms and save their performance.\n", " \n", " ## ERM-SVRG.\n", " mthidx = 0\n", " if mthidx in m_idx_todo: \n", " idx = 0\n", " for onestep in al_svrg:\n", " al_svrg.update(model=mod_learner, data=data)\n", " # Record performance\n", " loss_tr[tri,idx,mthidx] = np.mean(mod_learner.l_tr(w=al_svrg.w, data=data))-loss_star\n", " riskvals[tri,idx,mthidx] = risk(w=al_svrg.w)-risk_star\n", " truedist[tri,idx,mthidx] = np.linalg.norm(w_star-al_svrg.w)-0\n", " idx += 1\n", " \n", " ## Replication of ERM-SVRG using Chainer.\n", " mthidx = 1\n", " if mthidx in m_idx_todo:\n", " idx = 0\n", " t = 0\n", " iter_train = ch.iterators.SerialIterator(dataset=Z,\n", " batch_size=batchsize,\n", " repeat=True,\n", " shuffle=False)\n", " while t < t_max:\n", " \n", " # If condition holds, run \"outer loop\" update.\n", " if t % in_max == 0:\n", " \n", " # Use the output of \"inner loop\" as new snapshot.\n", " mod_snap = mod_chainer.copy(mode=\"copy\")\n", " \n", " # Use the full data set here.\n", " X_batch, y_batch = ch.dataset.concat_examples(Z)\n", " prediction_tr_snap = mod_snap(X_batch)\n", " \n", " # Compute loss and full-batch gradient.\n", " loss_snap = ch.functions.mean_squared_error(prediction_tr_snap, y_batch) / 2.0\n", " mod_snap.cleargrads()\n", " loss_snap.backward()\n", " \n", " # Store the gradient list for use in inner loop.\n", " grad_list = [np.copy(p.grad) for p in mod_snap.params()]\n", " \n", " \n", " # Mini-batch computations for inner loop.\n", " Z_batch = iter_train.next()\n", " X_batch, y_batch = ch.dataset.concat_examples(Z_batch)\n", " t += 1 # manage steps ourselves.\n", " \n", " # Predictions.\n", " prediction_tr = mod_chainer(X_batch)\n", " prediction_tr_snap = mod_snap(X_batch)\n", "\n", " # Loss computations (will feed the grad computations).\n", " loss = ch.functions.mean_squared_error(prediction_tr, y_batch) / 2.0\n", " loss_snap = ch.functions.mean_squared_error(prediction_tr_snap, y_batch) / 2.0\n", " #old_loss = np.mean(mod_learner.l_tr(w=mod_chainer.l1.W.data.T, data=data))\n", " \n", " # Gradient computations.\n", " mod_chainer.cleargrads()\n", " mod_snap.cleargrads()\n", " loss.backward()\n", " loss_snap.backward()\n", " \n", " # Parameter updates.\n", " zipped = zip(mod_chainer.params(), mod_snap.params(), grad_list)\n", " for p, p_snap, mu in zipped:\n", " grad = p.grad\n", " grad_snap = p_snap.grad\n", " if grad is None:\n", " continue\n", " else:\n", " adjust = grad_snap - mu\n", " p.data -= alphaval * (grad-adjust)\n", "\n", " # Record performance\n", " loss_tr[tri,idx,mthidx] = np.mean(mod_learner.l_tr(w=mod_chainer.l1.W.data.T, data=data))-np.mean(mod_learner.l_tr(w=w_star, data=data))\n", " riskvals[tri,idx,mthidx] = risk(w=mod_chainer.l1.W.data.T)-risk_star\n", " truedist[tri,idx,mthidx] = np.linalg.norm(w_star-mod_chainer.l1.W.data.T)-0\n", " idx += 1\n", "\n", "\n", "# Finally, take statistics of the performance metrics over all trials.\n", "ave_loss_tr = np.mean(loss_tr, axis=0)\n", "ave_riskvals = np.mean(riskvals, axis=0)\n", "ave_truedist = np.mean(truedist, axis=0)\n", "sd_loss_tr = np.std(loss_tr, axis=0)\n", "sd_riskvals = np.std(riskvals, axis=0)\n", "sd_truedist = np.std(truedist, axis=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__練習問題__\n", "\n", "0. `mod_snap`と`mod_chainer`の役割の違いを説明すること。\n", "\n", "0. `zipped`に基づくイテレーションでは、何が行われているか説明すること。\n", "\n", "0. Chainer向けのSVRGと自作のSVRGがまったく同じ性能を叩き出すと思われるか。その理由も併せて説明すること。" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Visualization of performance.\n", "\n", "tvals = np.arange(t_max)+1 # better to start from the first update.\n", "\n", "# Average over trials.\n", "myfig = plt.figure(figsize=(15,5))\n", "\n", "ax_loss_tr = myfig.add_subplot(1, 3, 1)\n", "for m in m_idx_todo:\n", " vals = ave_loss_tr[:,m]\n", " err = sd_loss_tr[:,m]\n", " ax_loss_tr.plot(tvals, vals, color=mth_colours[m], label=mth_names[m])\n", " #ax_loss_tr.errorbar(tvals, vals, yerr=err, fmt='-o', col=mth_colours[m], label=mth_names[m])\n", " ax_loss_tr.legend(loc=1,ncol=1)\n", " plt.axhline(y=0.0, color=\"black\")\n", " plt.title(\"Excess empirical risk\")\n", " \n", "\n", "ax_riskvals = myfig.add_subplot(1, 3, 2)\n", "for m in m_idx_todo:\n", " vals = ave_riskvals[:,m]\n", " err = sd_riskvals[:,m]\n", " err_log = err / vals\n", " ax_riskvals.semilogy(tvals, vals, \"-o\", color=mth_colours[m], label=mth_names[m])\n", " ax_riskvals.legend(loc=1,ncol=1)\n", " plt.axhline(y=0.0, color=\"black\")\n", " plt.title(\"Excess risk\")\n", "\n", "ax_variation = myfig.add_subplot(1, 3, 3)\n", "for m in m_idx_todo:\n", " vals = sd_riskvals[:,m]\n", " ax_variation.plot(tvals, vals, \"-o\", color=mth_colours[m], label=mth_names[m])\n", " ax_variation.legend(loc=1,ncol=1)\n", " plt.axhline(y=0.0, color=\"black\")\n", " plt.title(\"Variation of risk across samples\")\n", "\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "嬉しいことに、ほぼ同じ振る舞いを実現していることが確認できた。ランダムに取っているサブサンプルは使うたびに変わるので、まったく同じ動作はほぼ考えられないが、全体的な傾向が一致しており、Chainer版が誠実に自作版を再現していることが窺える。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "___" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 数値実験の概要\n", "\n", "この節では、Johnson and Zhang (2013)の数値実験の全体像を眺めてから、重要な実験条件を整理しておくことにする。実際にその数値実験を実装するのは、次の節にする。\n", "\n", "彼らの実験では、複数の実世界からのデータセットが使われており、いずれも機械学習の世界で有名なベンチマークデータである。パフォーマンスの評価指標として、主に以下の3つを見ている。\n", "\n", "- 訓練データでの損失\n", "- 検証データでの損失\n", "- 重みベクトルを更新するたびの分散（\"update variance\"と呼んでいる）\n", "\n", "これらの数量は基本的に、__計算コスト__の関数として、そのグラフがプロットされている。彼らがいう計算コストとは、$d$次元勾配ベクトルを算出した累計回数である。代表的な結果を参考として下図で示しておく。\n", "\n", "\"Example" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Johnsonらの実験では、識別課題のみ扱っている。基本的には、同じデータセットに対して、2種類の実験を行なっている。\n", "\n", "- 凸： ロジスティック回帰を使う場合を指す。ロス関数が重みベクトルの凸関数である。\n", "\n", "- 非凸： フィードフォワードニューラルネットワークを使う場合を指す。ネットワークの詳細として、隠れそうが一つだけで、接続はfully-connectedで、活性化関数が何らかのsigmoidである。全クラス分の実数値出力を最後にsoftmax cross-entropyに渡している。ミニバッチの大きさは10と決まっている。モデルが非線形のため、一般には目的関数が重みベクトルの凸関数ではない。\n", "\n", "例のupdate varianceの計算について、以下を引用する。\n", "\n", "> In Fig. 2 (c), we show the variance of SVRG update $-\\eta (\\nabla \\psi_{i}(w)-\\psi_{i}(\\tilde{w})+\\tilde{\\mu})$ in comparison with the variance of SGD update $-\\eta(\\nabla \\psi_{i}(w))$ and SDCA. As expected, the variance (including multiplication with the learning rate) of both SVRG and SDCA decreases as optimization proceeds, and the variance of SGD with a fixed learning rate (‘SGD:0.001’) stays high.\n", "\n", "彼らの記号は我々の記号と異なるので、論文中の定式化の部分を読み、正しい計算を確認すること。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "そのほか、彼らの実験を再現するにあたって必要な情報をまとめている。\n", "\n", "- 内側ループの反復回数： $2n$(凸)、$5n$(非凸)。\n", "\n", "- SVRGの初期化： SGDをone epoch(凸)かten epochs（非凸）走らせた結果を初期値とする。\n", "\n", "- すべての実験では、$\\ell_{2}$ノルムによる正則化が行われている。その罰則項の係数はデータセットによる。MNISTでは1e-4、CIFAR-10では1e-3、など（凸も非凸も同じ設定）。\n", "\n", "- 学習率（\"learning rates\"、つまりステップサイズのこと）はFigureの中に明記されている。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "___" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "## 学習と性能検証\n", "\n", "いよいよ数値実験を実装し、ベンチマークデータを相手に、実行していく。以下のコードでは、SVRGを検証する実験を、凸(多クラスのロジスティック回帰)と非凸(ニューラルネットワーク＋softmax)の両ケースで実装している。この原始的なコードを頼りに、下記の__練習問題__に取り組むこと。\n", "\n", "0. ステップサイズや正則化の係数、外側と内側の反復回数の上限などは恣意的に決めている。これらを、前節の内容や元論文の中身を踏まえて、論文どおりに正しく設定すること。\n", "\n", "0. 非凸のケースでは、SVRGは実装しているが、SGDは実装していない。前の章のChainer基礎を頼りに、非線形モデル向けにSGDを実装すること。また、SGDとSVRGの実験結果を比較すること。\n", "\n", "0. 以下のコードでは、非線形モデルのとき、$\\ell_{2}$ノルムによる正則化をどのように実装しているか説明すること。\n", "\n", "0. 以下のコードでは、非線形モデルのとき、例のupdate varianceがどのように算出されているか説明すること。\n", "\n", "0. 以下のコードでは、ステップサイズは固定値である（いわゆるlearning rate schedulingは行っていない）。元論文では、固定値に加えて、2種類のschedulingもカバーされている。元論文を読み、この2種類を突き止めて、SGD＋schedulingを実装すること。最終的に目指したいのは、Johnsonらがいう\"SGD-best\"の実装である。" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "import os\n", "import math\n", "import tables\n", "import numpy as np\n", "import multiprocessing as mltp\n", "\n", "import algorithms\n", "import models\n", "import models_ch\n", "import dataclass\n", "import helpers as hlp" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Data set choice.\n", "\n", "paths = {\n", " \"cifar10\": os.path.join(\"data\", \"cifar10\", \"data.h5\"),\n", " \"mnist\": os.path.join(\"data\", \"mnist\", \"data.h5\"),\n", " \"iris\": os.path.join(\"data\", \"iris\", \"data.h5\")\n", "}\n", "\n", "task_name = \"iris\" # SET BY HAND." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# General-purpose performance evaluation.\n", "def perf_fn(model=None, algo=None, data=None):\n", " '''\n", " Performance measurement routine.\n", " Various metrics are computed, relevant descriptions\n", " are given as names, and both are returned together\n", " in a dictionary.\n", " '''\n", "\n", " names = [\"Misclass rate (train)\",\n", " \"Misclass rate (test)\",\n", " \"Primal objective (train)\",\n", " \"Primal objective (test)\",\n", " \"Norm (l2)\"]\n", "\n", " # In the case of a dry run, leave perf Null.\n", " if ((model is None) or (algo is None)):\n", " return {\"names\": names, \"perf\": None}\n", "\n", " # Else, compute the performance metrics of interest.\n", " y_est_tr = model.classify(w=algo.w, X=data.X_tr)\n", " y_est_te = model.classify(w=algo.w, X=data.X_te)\n", "\n", " perf_tr = model.class_perf(y_est=y_est_tr, y_true=data.y_tr)\n", " perf_te = model.class_perf(y_est=y_est_te, y_true=data.y_te)\n", "\n", " misclass_tr = perf_tr[\"rate\"]\n", " misclass_te = perf_te[\"rate\"]\n", " \n", " primal_tr = np.mean(model.l_tr(w=algo.w, data=data))\n", " primal_te = np.mean(model.l_te(w=algo.w, data=data))\n", "\n", " w_norm = np.linalg.norm(algo.w)\n", " \n", " perf = np.array([misclass_tr, misclass_te,\n", " primal_tr, primal_te,\n", " w_norm])\n", " \n", " out = {\"names\": names,\n", " \"perf\": perf}\n", " \n", " return out\n", "\n", "\n", "# Performance evaluation for Chainer-based implementation.\n", "def perf_fn_ch(model=None, data=None):\n", " '''\n", " Performance measurement routine; Chainer version.\n", " Various metrics are computed, relevant descriptions\n", " are given as names, and both are returned together\n", " in a dictionary.\n", " \n", " NOTE: the \"model\" here contains all parameters.\n", " '''\n", " \n", " names = [\"Misclass rate (train)\",\n", " \"Misclass rate (test)\",\n", " \"Primal objective (train)\",\n", " \"Primal objective (test)\",\n", " \"Norm (l2)\"]\n", "\n", " # In the case of a dry run, leave perf Null.\n", " if (model is None or data is None):\n", " return {\"names\": names, \"perf\": None}\n", "\n", " # Else, compute the performance metrics of interest.\n", " \n", " ## Get predictions (not tuple notation).\n", " prediction_tr = model(data.X_tr)\n", " prediction_te = model(data.X_te)\n", " \n", " ## Compute misclassification rate.\n", " accuracy_tr = ch.functions.accuracy(y=prediction_tr,\n", " t=np.int8(data.y_tr).flatten()).data\n", " accuracy_te = ch.functions.accuracy(y=prediction_te,\n", " t=np.int8(data.y_te).flatten()).data\n", " misclass_tr = 1-accuracy_tr\n", " misclass_te = 1-accuracy_te\n", " \n", " ## Compute loss function values.\n", " primal_tr = ch.functions.softmax_cross_entropy(x=prediction_tr,\n", " t=np.int8(data.y_tr).flatten(),\n", " normalize=True,\n", " reduce=\"mean\").data\n", " \n", " primal_te = ch.functions.softmax_cross_entropy(x=prediction_te,\n", " t=np.int8(data.y_te).flatten(),\n", " normalize=True,\n", " reduce=\"mean\").data\n", " \n", " ## Finally compute the norm.\n", " w_norm = 0\n", " for p in model.params():\n", " w_norm += np.linalg.norm(p.data)**2\n", " w_norm = math.sqrt(w_norm)\n", " \n", " \n", " perf = np.array([misclass_tr, misclass_te,\n", " primal_tr, primal_te,\n", " w_norm])\n", " \n", " out = {\"names\": names,\n", " \"perf\": perf}\n", " \n", " return out" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 線形モデル向けの検証（目的関数が凸である）\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# Basically a \"driver script\" for our hand-built guys.\n", "\n", "num_trials = 5\n", "\n", "# Prepare a results folder, if doesn't already exist.\n", "hlp.makedir_safe(os.path.join(\"results\", task_name))\n", "\n", "# Establish file connection.\n", "toread = paths[task_name]\n", "f = tables.open_file(toread, mode=\"r\")\n", "\n", "# Prepare data object.\n", "data = dataclass.DataSet()\n", "data.init_tr(X=f.root.train.inputs.read(),\n", " y=f.root.train.labels.read())\n", "data.init_te(X=f.root.test.inputs.read(),\n", " y=f.root.test.labels.read())" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Prepare model object.\n", "mod = models.LogisticReg(data=data)\n", "\n", "# Initialize all competing hand-built algorithms.\n", "n, numfeats = data.X_tr.shape\n", "nc = mod.nc\n", "d = numfeats * (nc-1)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "perf_names = perf_fn()[\"names\"] # fire a blank to get metric names.\n", "num_metrics = len(perf_names) # number of perf metrics used." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# Algorithm preparation.\n", "\n", "num_epochs = 10\n", "replace = False\n", "thres = 1e-03\n", "store = False\n", "lamreg = 1e-03 # should adjust depending on data set.\n", "\n", "def alpha_fixed(t, val):\n", " return val\n", "\n", "def make_step(u):\n", " def mystep(t, model=None, data=None, newdir=None):\n", " return alpha_fixed(t=t, val=u)\n", " return mystep\n", "\n", "def algoFn_sgd(w_init):\n", " al = algorithms.Algo_SGD(w_init=w_init,\n", " step=make_step(u=0.01),\n", " batchsize=1,\n", " replace=replace,\n", " t_max=num_epochs*n,\n", " thres=thres,\n", " store=store,\n", " lamreg=lamreg)\n", " return al\n", "\n", "def algoFn_svrg(w_init):\n", " al = algorithms.Algo_SVRG(w_init=w_init,\n", " step=make_step(u=0.1),\n", " batchsize=1,\n", " replace=replace,\n", " out_max=num_epochs/2,\n", " in_max=2*n,\n", " thres=thres,\n", " store=store,\n", " lamreg=lamreg)\n", " return al\n", "\n", "algoFn_dict = {\"sgd\": algoFn_sgd,\n", " \"svrg\": algoFn_svrg}" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# Max number of perf records.\n", "max_records = num_epochs + 1 # extra one for initial values." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Run the algorithms, and write performance to disk.\n", "\n", "def worker(algorithm_name):\n", " \n", " print(\"At work:\", algorithm_name)\n", " \n", " # Array used for recording cumulative costs.\n", " perf_cumcost = np.zeros(max_records, dtype=np.uint32)\n", " perf_cumcost.fill(np.nan)\n", "\n", " # Array used for recording update variance.\n", " perf_updatevar = np.zeros(max_records, dtype=np.float32)\n", " perf_updatevar.fill(np.nan)\n", "\n", " # Array used for housing performance over trials.\n", " perf_array = np.zeros((max_records, num_metrics, num_trials),\n", " dtype=np.float32)\n", " perf_array.fill(np.nan)\n", " \n", " for tri in range(num_trials):\n", "\n", " # Initialize weights and algorithm here.\n", " w_init = np.random.uniform(low=0.0, high=0.1, size=(d,1))\n", " al = algoFn_dict[algorithm_name](w_init=w_init)\n", "\n", " cntr = 0\n", " for onestep in al:\n", "\n", " if al.t % 5000 == 0:\n", " print(\"Update: t =\", al.t)\n", "\n", " al.update(model=mod, data=data) # update parameters.\n", "\n", " if al.torecord:\n", " al.torecord = False # switch off.\n", " perf_updatevar[cntr] = al.diff\n", " perf_array[cntr,:,tri] = perf_fn(model=mod,\n", " algo=al,\n", " data=data)[\"perf\"]\n", " perf_cumcost[cntr] = al.cumcost\n", " cntr += 1\n", "\n", " # Finally, if cntr isn't already maxed out, be sure\n", " # to record performance at the final step.\n", " if cntr < max_records:\n", " perf_updatevar[cntr] = np.linalg.norm(al.w-al.w_old)\n", " perf_array[cntr,:,tri] = perf_fn(model=mod,\n", " algo=al,\n", " data=data)[\"perf\"]\n", " perf_cumcost[cntr] = al.cumcost\n", "\n", " # Having run over all trials, compute statistics.\n", " # note: ndarray shape is (max_records, num_metrics).\n", " perf_ave = np.mean(perf_array, axis=2)\n", " perf_sd = np.std(perf_array, axis=2)\n", "\n", " # Trim the unfilled results (as needed).\n", " tocheck = np.where(np.isnan(perf_ave[:,0]))[0]\n", " if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_ave = perf_ave[0:badidx,:]\n", "\n", " tocheck = np.where(np.isnan(perf_sd[:,0]))[0]\n", " if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_sd = perf_sd[0:badidx,:]\n", "\n", " tocheck = np.where(np.isnan(perf_cumcost))[0]\n", " if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_cumcost = perf_cumcost[0:badidx,:]\n", "\n", " tocheck = np.where(np.isnan(perf_updatevar))[0]\n", " if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_updatevar = perf_updatevar[0:badidx]\n", "\n", " # Write to disk.\n", " towrite = os.path.join(\"results\", task_name)\n", " np.savetxt(fname=os.path.join(towrite, (algorithm_name+\".cost\")),\n", " X=perf_cumcost, fmt=\"%d\", delimiter=\",\")\n", " np.savetxt(fname=os.path.join(towrite, (algorithm_name+\".upvar\")),\n", " X=perf_updatevar, fmt=\"%.7e\", delimiter=\",\")\n", " np.savetxt(fname=os.path.join(towrite, (algorithm_name+\".ave\")),\n", " X=perf_ave, fmt=\"%.7e\", delimiter=\",\")\n", " np.savetxt(fname=os.path.join(towrite, (algorithm_name+\".sd\")),\n", " X=perf_sd, fmt=\"%.7e\", delimiter=\",\")\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Our machine has 12 CPUs.\n", "Of these, 12 are available.\n", "At work: svrg\n", "At work: sgd\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n", "Update: t = 0\n" ] } ], "source": [ "if __name__ == \"__main__\":\n", " cpu_count = mltp.cpu_count()\n", " print(\"Our machine has\", cpu_count, \"CPUs.\")\n", " print(\"Of these,\", len(os.sched_getaffinity(0)), \"are available.\")\n", " \n", " # Put all processors to work (at an upper limit).\n", " mypool = mltp.Pool(cpu_count)\n", " \n", " # Pass the \"worker\" the name of the algorithm to run.\n", " mypool.map(func=worker, iterable=algoFn_dict.keys())\n", "\n", " # Memory management.\n", " mypool.close() # important for stopping memory leaks.\n", " mypool.join() # wait for all workers to exit.\n", " \n", " # END of multiproc procedure." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# Close file connection.\n", "f.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 線形モデル向けの検証（目的関数が非凸である）\n", "\n", "ここでは、線形モデルのときとほぼ同じ段取りではあるが、今回はニューラルネットワークによる非線形モデルで、自作のものに代わって、Chainerで実装したものを使う。\n", "\n", "彼らの非線形モデルを`Chain_JZ`というサブクラスで実装する。" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "class Chain_JZ(ch.Chain):\n", " '''\n", " The neural network used by Johnson and Zhang (2013).\n", " '''\n", " \n", " def __init__(self,\n", " out_l0,\n", " out_l1,\n", " out_l2,\n", " init_delta=1.0,\n", " nobias=False):\n", " super(Chain_JZ, self).__init__()\n", " \n", " with self.init_scope():\n", " self.l1 = models_ch.Linear(in_size=out_l0,\n", " out_size=out_l1,\n", " init_W=None,\n", " init_b=None,\n", " init_delta=init_delta,\n", " nobias=True)\n", " self.l2 = models_ch.Linear(in_size=out_l1,\n", " out_size=out_l2,\n", " init_W=None,\n", " init_b=None,\n", " init_delta=init_delta,\n", " nobias=True)\n", " \n", " def __call__(self, x):\n", " out = ch.functions.sigmoid(self.l1(x)) # logistic sigmoid.\n", " out = self.l2(out) # return the un-normalized log-probabilities.\n", " return out" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "# Basically a \"driver script\" for our CHAINER-built guys.\n", "\n", "num_trials = 5\n", "\n", "# Prepare a results folder, if doesn't already exist.\n", "hlp.makedir_safe(os.path.join(\"results\", task_name))\n", "\n", "# Establish file connection.\n", "toread = paths[task_name]\n", "f = tables.open_file(toread, mode=\"r\")\n", " \n", "# Prepare data object for Chainer.\n", "Z_tr = ch.datasets.TupleDataset(np.float32(f.root.train.inputs.read()),\n", " np.int8(f.root.train.labels.read()))\n", "\n", "data = dataclass.DataSet()\n", "data.init_tr(X=f.root.train.inputs.read(),\n", " y=f.root.train.labels.read())\n", "data.init_te(X=f.root.test.inputs.read(),\n", " y=f.root.test.labels.read())" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "n, numfeats = data.X_tr.shape\n", "nc = len(np.unique(data.y_tr))\n", "d = numfeats * (nc-1)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [], "source": [ "perf_names = perf_fn_ch()[\"names\"] # fire a blank to get metric names.\n", "num_metrics = len(perf_names) # number of perf metrics used." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# Algorithm preparation.\n", "num_epochs = 10\n", "replace = False\n", "thres = 1e-03\n", "store = False\n", "lamreg = 1e-03 # should adjust depending on data set.\n", "alphaval = 0.05\n", "\n", "in_max = n\n", "out_max = num_epochs\n", "t_max = out_max * in_max\n", "\n", "al_name = \"svrg-ch\"" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "# Max number of perf records.\n", "max_records = num_epochs + 1 # extra one for initial values." ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Run the algorithms, and write performance to disk.\n", "\n", "# Array used for recording cumulative costs.\n", "perf_cumcost = np.empty(max_records)\n", "perf_cumcost.fill(np.nan)\n", "\n", "# Array used for recording update variance.\n", "perf_updatevar = np.empty(max_records)\n", "perf_updatevar.fill(np.nan)\n", "\n", "# Array used for housing performance over trials.\n", "perf_array = np.zeros((max_records, num_metrics, num_trials))\n", "perf_array.fill(np.nan)\n", "\n", "for tri in range(num_trials):\n", " \n", " # Initialize models (Chainer-based).\n", " mod_svrg = Chain_JZ(out_l0=numfeats,\n", " out_l1=100,\n", " out_l2=nc,\n", " nobias=True)\n", " \n", " mod_snap = Chain_JZ(out_l0=numfeats,\n", " out_l1=100,\n", " out_l2=nc,\n", " nobias=True)\n", " \n", " # Execution of SVRG.\n", " idx = 0\n", " cntr = 0\n", " cumcost = 0\n", " t = 0\n", " iter_train = ch.iterators.SerialIterator(dataset=Z_tr,\n", " batch_size=1,\n", " repeat=True,\n", " shuffle=True)\n", " \n", " while t < t_max:\n", " \n", " # If condition holds, run \"outer loop\" update.\n", " if t % in_max == 0:\n", " \n", " # Turn on the \"to record\" flag.\n", " torecord = True\n", " \n", " # Use the output of \"inner loop\" as new snapshot.\n", " mod_snap = mod_svrg.copy(mode=\"copy\")\n", " \n", " # Use the full data set here.\n", " prediction_tr_snap = mod_snap(data.X_tr)\n", "\n", " # Compute loss and full-batch gradient.\n", " loss_snap = ch.functions.softmax_cross_entropy(x=prediction_tr_snap,\n", " t=np.int8(data.y_tr).flatten(),\n", " normalize=True,\n", " reduce=\"mean\")\n", " mod_snap.cleargrads()\n", " loss_snap.backward()\n", " \n", " # Store the gradient list for use in inner loop.\n", " grad_list = [np.copy(p.grad) for p in mod_snap.params()]\n", " \n", " # Update cumulative cost.\n", " cumcost += data.X_tr.shape[0]\n", " \n", " # In any case, run typical \"inner loop\" update.\n", " \n", " ## Mini-batch computations for inner loop.\n", " Z = iter_train.next()\n", " X, y = ch.dataset.concat_examples(Z)\n", " t += 1 # manage steps ourselves.\n", " \n", " ## Predictions.\n", " prediction_tr = mod_svrg(X)\n", " prediction_tr_snap = mod_snap(X)\n", " \n", " ## Loss computations (will feed the grad computations).\n", " loss = ch.functions.softmax_cross_entropy(x=prediction_tr,\n", " t=y.flatten(),\n", " normalize=True,\n", " reduce=\"mean\")\n", " \n", " loss_snap = ch.functions.softmax_cross_entropy(x=prediction_tr_snap,\n", " t=y.flatten(),\n", " normalize=True,\n", " reduce=\"mean\")\n", " \n", " ## Gradient computations.\n", " mod_svrg.cleargrads()\n", " mod_snap.cleargrads()\n", " loss.backward()\n", " loss_snap.backward()\n", " \n", " ## Update cumulative cost.\n", " cumcost += 2\n", " \n", " # Prepare fresh update variance (squared).\n", " upvar_sq = 0 \n", " \n", " ## Parameter updates.\n", " zipped = zip(mod_svrg.params(), mod_snap.params(), grad_list)\n", " for p, p_snap, mu in zipped:\n", " grad = p.grad\n", " grad_snap = p_snap.grad\n", " if grad is None:\n", " continue\n", " else:\n", " adjust = grad_snap - mu\n", " p.data *= (1-2*lamreg*alphaval) # this is l2-squared regularization.\n", " p.data -= alphaval * (grad-adjust)\n", " upvar_sq += np.linalg.norm(alphaval*(grad-adjust))**2\n", " \n", " ## Record performance.\n", " if torecord:\n", " torecord = False # switch off.\n", " perf_updatevar[cntr] = math.sqrt(upvar_sq)\n", " perf_array[cntr,:,tri] = perf_fn_ch(\n", " model=mod_svrg,\n", " data=data\n", " )[\"perf\"]\n", " perf_cumcost[cntr] = cumcost\n", " cntr += 1\n", " \n", " \n", "# Having run over all trials, compute statistics.\n", "# note: ndarray shape is (max_records, num_metrics).\n", "perf_ave = np.mean(perf_array, axis=2)\n", "perf_sd = np.std(perf_array, axis=2)\n", "\n", "# Trim the unfilled results (as needed).\n", "tocheck = np.where(np.isnan(perf_ave[:,0]))[0]\n", "if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_ave = np.float32(perf_ave[0:badidx,:])\n", "\n", "tocheck = np.where(np.isnan(perf_sd[:,0]))[0]\n", "if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_sd = np.float32(perf_sd[0:badidx,:])\n", "\n", "tocheck = np.where(np.isnan(perf_cumcost))[0]\n", "if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_cumcost = np.uint32(perf_cumcost[0:badidx])\n", "\n", "tocheck = np.where(np.isnan(perf_updatevar))[0]\n", "if tocheck.size > 0:\n", " badidx = tocheck[0]\n", " perf_updatevar = np.float32(perf_updatevar[0:badidx])\n", "\n", "# Write to disk.\n", "towrite = os.path.join(\"results\", task_name)\n", "np.savetxt(fname=os.path.join(towrite, (al_name+\".cost\")),\n", " X=perf_cumcost, fmt=\"%d\", delimiter=\",\")\n", "np.savetxt(fname=os.path.join(towrite, (al_name+\".upvar\")),\n", " X=perf_updatevar, fmt=\"%.7e\", delimiter=\",\")\n", "np.savetxt(fname=os.path.join(towrite, (al_name+\".ave\")),\n", " X=perf_ave, fmt=\"%.7e\", delimiter=\",\")\n", "np.savetxt(fname=os.path.join(towrite, (al_name+\".sd\")),\n", " X=perf_sd, fmt=\"%.7e\", delimiter=\",\")\n", "\n" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "# Close file connection.\n", "f.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### パフォーマンスの評価\n", "\n", "上の2つの節を経て、実験結果がディスクに保存されているはずである。この結果を簡単に可視化すると、傾向が一目瞭然である。" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import math\n", "import numpy as np\n", "import os" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "perf_names = perf_fn()[\"names\"] # fire a blank to get metric names.\n", "num_metrics = len(perf_names) # number of perf metrics used." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Names of methods to select from:\n", "['sgd' 'svrg' 'svrg-ch']\n" ] } ], "source": [ "# Task name is fixed throughout all the tests below. Make sure we're consistent.\n", "task_name = \"iris\"\n", "\n", "perf_names = perf_fn()[\"names\"] # fire a blank to get metric names.\n", "\n", "results_dir = os.path.join(\"results\", task_name) # Parent dir of all results.\n", "\n", "# A few lines of code to extract all the method names.\n", "names_results = os.listdir(results_dir)\n", "names_methods = []\n", "for s in names_results:\n", " tmp_split = s.split(\".\")[0:-1]\n", " names_methods += [\".\".join(tmp_split)]\n", " \n", "names_methods = np.array(names_methods)\n", "names_methods = np.unique(names_methods) # Clean out duplicates.\n", "print(\"Names of methods to select from:\")\n", "print(names_methods)\n" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "myfig = plt.figure(figsize=(15,10))\n", "\n", "\n", "ax = myfig.add_subplot(2,3,1)\n", "perf_idx = 1\n", "for al_name in names_methods:\n", " \n", " # First get the costs.\n", " toread = os.path.join(results_dir, (al_name+\".cost\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_cost = np.loadtxt(fname=f, dtype=np.uint32, delimiter=\",\")\n", " \n", " toread = os.path.join(results_dir, (al_name+\".ave\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_ave = np.loadtxt(fname=f, dtype=np.float32, usecols=perf_idx, delimiter=\",\")\n", " ax.plot(toplot_cost, toplot_ave, \"o-\", label=al_name)\n", " ax.legend(loc=1,ncol=1)\n", " plt.title(\"Performance: \"+perf_names[perf_idx])\n", " \n", " \n", "ax = myfig.add_subplot(2,3,2)\n", "perf_idx = 3\n", "for al_name in names_methods:\n", " \n", " # First get the costs.\n", " toread = os.path.join(results_dir, (al_name+\".cost\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_cost = np.loadtxt(fname=f, dtype=np.uint32, delimiter=\",\")\n", " \n", " toread = os.path.join(results_dir, (al_name+\".ave\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_ave = np.loadtxt(fname=f, dtype=np.float32, usecols=perf_idx, delimiter=\",\")\n", " ax.plot(toplot_cost, toplot_ave, \"o-\", label=al_name)\n", " ax.legend(loc=1,ncol=1)\n", " plt.title(\"Performance: \"+perf_names[perf_idx])\n", " \n", " \n", "ax = myfig.add_subplot(2,3,3)\n", "perf_idx = None\n", "for al_name in names_methods:\n", " \n", " # First get the costs.\n", " toread = os.path.join(results_dir, (al_name+\".cost\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_cost = np.loadtxt(fname=f, dtype=np.uint32, delimiter=\",\")\n", "\n", " toread = os.path.join(results_dir, (al_name+\".upvar\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_upvar = np.loadtxt(fname=f, dtype=np.float32, usecols=perf_idx, delimiter=\",\")\n", " ax.plot(toplot_cost, toplot_upvar, \"o-\", label=al_name)\n", " ax.legend(loc=1,ncol=1)\n", " plt.title(\"Performance: update variance\")\n", " \n", " \n", "ax = myfig.add_subplot(2,3,4)\n", "perf_idx = 0\n", "for al_name in names_methods:\n", " \n", " # First get the costs.\n", " toread = os.path.join(results_dir, (al_name+\".cost\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_cost = np.loadtxt(fname=f, dtype=np.uint32, delimiter=\",\")\n", " \n", " toread = os.path.join(results_dir, (al_name+\".ave\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_ave = np.loadtxt(fname=f, dtype=np.float32, usecols=perf_idx, delimiter=\",\")\n", " ax.plot(toplot_cost, toplot_ave, \"o-\", label=al_name)\n", " ax.legend(loc=1,ncol=1)\n", " plt.title(\"Performance: \"+perf_names[perf_idx])\n", " \n", " \n", "ax = myfig.add_subplot(2,3,5)\n", "perf_idx = 2\n", "for al_name in names_methods:\n", " \n", " # First get the costs.\n", " toread = os.path.join(results_dir, (al_name+\".cost\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_cost = np.loadtxt(fname=f, dtype=np.uint32, delimiter=\",\")\n", " \n", " toread = os.path.join(results_dir, (al_name+\".ave\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_ave = np.loadtxt(fname=f, dtype=np.float32, usecols=perf_idx, delimiter=\",\")\n", " ax.plot(toplot_cost, toplot_ave, \"o-\", label=al_name)\n", " ax.legend(loc=1,ncol=1)\n", " plt.title(\"Performance: \"+perf_names[perf_idx])\n", " \n", " \n", "\n", "ax = myfig.add_subplot(2,3,6)\n", "perf_idx = 4\n", "for al_name in names_methods:\n", " \n", " # First get the costs.\n", " toread = os.path.join(results_dir, (al_name+\".cost\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_cost = np.loadtxt(fname=f, dtype=np.uint32, delimiter=\",\")\n", " \n", " toread = os.path.join(results_dir, (al_name+\".ave\"))\n", " with open(toread, mode=\"r\", encoding=\"ascii\") as f:\n", " toplot_ave = np.loadtxt(fname=f, dtype=np.float32, usecols=perf_idx, delimiter=\",\")\n", " ax.plot(toplot_cost, toplot_ave, \"o-\", label=al_name)\n", " ax.legend(loc=1,ncol=1)\n", " plt.title(\"Performance: \"+perf_names[perf_idx])\n", "\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "___\n" ] } ], "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.5" } }, "nbformat": 4, "nbformat_minor": 2 }