pSBPS_fig.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Compare SBPS to pSBPS - logistic regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Import libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-03 20:48:55.849894: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/darg/Documents/IntelliJ_Projects/DNI/venv/lib/python3.9/site-packages/tensorflow/python/compat/v2_compat.py:107: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    }
   ],
   "source": [
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()\n",
    "#import tensorflow as tf\n",
    "import numpy as np\n",
    "from samplers import *\n",
    "from utils import *\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline \n",
    "from sklearn import linear_model\n",
    "import copy\n",
    "import scipy.stats\n",
    "import itertools\n",
    "import os\n",
    "import time\n",
    "sess = tf.compat.v1.InteractiveSession()\n",
    "tf.compat.v1.disable_eager_execution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Data generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "# Generate logistic regression data\n",
    "D =   20\n",
    "N = 1000\n",
    "target_w = 10*(np.random.rand(D) - .5)\n",
    "train_images = np.random.rand(N,D) - .5\n",
    "cov = np.diag(np.ones(D))\n",
    "cov[0,0] = 1/float(500)\n",
    "#cov = np.linalg\n",
    "for i in range(N):\n",
    "    train_images[i,:] = np.random.multivariate_normal(np.zeros(D),cov)\n",
    "base=np.float64\n",
    "tfbase=tf.float64\n",
    "train_probs = logit(np.dot(train_images,target_w))\n",
    "train_labels = np.expand_dims(train_probs<np.random.rand(N),1).astype(base)\n",
    "data = np.float64( train_images.reshape( train_labels.shape[0], train_images[0].size ) )\n",
    "labels = train_labels\n",
    "probs=logit(np.matmul(train_images, target_w))\n",
    "def test_error():\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.79837755 -0.10210419 -0.15692887  0.02388174  0.04541383  0.02447948\n",
      "   0.02583089  0.02829573 -0.09798444 -0.19465376 -0.12514626 -0.01877565\n",
      "  -0.20436867  0.14508538 -0.13229052  0.28889192 -0.01287721 -0.0719918\n",
      "  -0.12300726  0.12415859]]\n"
     ]
    }
   ],
   "source": [
    "# Use SKLearn to run SAG\n",
    "import sklearn.linear_model as lin_mod\n",
    "skLogistic=lin_mod.LogisticRegression(fit_intercept=False,solver='sag',C=1e10,max_iter=N*10,tol=1e-6)\n",
    "skLogistic.fit(data,np.reshape(labels,[N,]))\n",
    "W_map=skLogistic.coef_.copy()\n",
    "probs_sk=logit(np.matmul(train_images, np.reshape(W_map,[D,1])))\n",
    "print(W_map-target_w) # show differences in W\n",
    "W_map = np.transpose(W_map)\n",
    "W_map = np.squeeze(W_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### Model Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    },
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "xPH = tf.compat.v1.placeholder(tfbase, [None,D])\n",
    "yPH = tf.compat.v1.placeholder(tfbase, [None,1],)\n",
    "W = tf.Variable(tf.zeros([D,1],tfbase),tfbase)\n",
    "all_weights = [W]\n",
    "w_shapes = [W.get_shape()]\n",
    "linProd= tf.matmul(xPH,W)\n",
    "objective=tf.nn.sigmoid_cross_entropy_with_logits(logits=linProd,labels=yPH)\n",
    "NLL=tf.reduce_mean(objective)\n",
    "# Create an ExponentialMovingAverage object\n",
    "\n",
    "# operation to calculate gradient and return gradient\n",
    "opt = tf.compat.v1.train.GradientDescentOptimizer(learning_rate=1)\n",
    "grads_and_vars = opt.compute_gradients(NLL, all_weights)\n",
    "gradients, variables = zip(*grads_and_vars)\n",
    "weights = tf.reshape(variables[0],[D])\n",
    "gPH = tf.compat.v1.placeholder(tfbase,[D])\n",
    "grads_to_apply = []\n",
    "grads_to_apply.append(tf.reshape(gPH,[D,1]))\n",
    "grad_and_vars_to_apply=list(zip(grads_to_apply, variables))\n",
    "tf_train_step = opt.apply_gradients(grad_and_vars_to_apply)\n",
    "\n",
    "vPH=tf.compat.v1.placeholder(tfbase,[D])\n",
    "yPred=tf.sigmoid(linProd)\n",
    "xPHR=tf.reshape(xPH,[-1,D])\n",
    "gradient_explicit=-(yPH-yPred)*xPHR\n",
    "tf_grad_calc=tf.reduce_mean(gradient_explicit,0)\n",
    "gradient_variance_calculation=tf.reduce_mean(gradient_explicit*gradient_explicit,0) \\\n",
    "    -tf_grad_calc*tf_grad_calc\n",
    "better_gradient_variance_intermediate=tf.matmul(gradient_explicit,tf.reshape(vPH,[D,1]))\n",
    "tf_grad_var_calc=tf.nn.moments(better_gradient_variance_intermediate,[0])[1]\n",
    "hessian_explicit= tf.reshape(yPred*(1-yPred),[-1,1,1])*(tf.reshape(xPHR,[-1,D,1])*tf.reshape(xPHR,[-1,1,D]))\n",
    "hessian_calculation=tf.reduce_mean(hessian_explicit,0)\n",
    "\n",
    "correct_prediction = tf.equal(yPH, tf.cast(.5+.5*tf.sign(tf.matmul(xPH, W)),tfbase))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_prediction,tfbase))\n",
    "\n",
    "# wrapping tf functions to pass to run_sampler and generate_sbps_samples\n",
    "def grad_calc(data,labels):\n",
    "    return tf_grad_calc.eval(feed_dict={xPH: data, yPH: labels})\n",
    "def grad_var_calc(data,labels,v):\n",
    "    return tf_grad_var_calc.eval(feed_dict={xPH: data, yPH: labels, vPH: v})\n",
    "def train_step(g):\n",
    "    return tf_train_step.run(feed_dict={gPH: g})\n",
    "weights = flatten_tensor_list(all_weights)\n",
    "def get_weights():\n",
    "    return weights.eval()\n",
    "# function to assign weights\n",
    "assign_weights_ops = []\n",
    "curr_ind = 0\n",
    "w_to_assign = tf.compat.v1.placeholder(tfbase,[D],name='w_to_assign')\n",
    "for [weight,shape] in zip(all_weights,w_shapes):\n",
    "    assign_weights_ops.append(weight.assign(tf.reshape(w_to_assign[curr_ind:curr_ind + int(np.prod(shape))],shape)))\n",
    "    curr_ind += int(np.prod(shape))\n",
    "def set_weights(w):\n",
    "    for a_w in assign_weights_ops:\n",
    "        sess.run(a_w,feed_dict={w_to_assign:w})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "### function to initialize session and run optimization/sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "condition number  1005.3618936878329\n"
     ]
    }
   ],
   "source": [
    "# Calculate Hessian\n",
    "sess.run(tf.compat.v1.global_variables_initializer())\n",
    "set_weights(W_map)\n",
    "hessian_map=hessian_calculation.eval(feed_dict={xPH: data, yPH: labels})\n",
    "hessian_map=hessian_map*N\n",
    "cov_map=np.linalg.inv(hessian_map)\n",
    "cond_num = np.max(np.linalg.eig(hessian_map)[0])/float(np.min(np.linalg.eig(hessian_map)[0]))\n",
    "print ('condition number ', cond_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Run samplers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running 1000 epochs (10000.0 iterations) per method\n",
      "Running SBPS, k = 3\n",
      "Evaluating Test error / NLL -  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-03 20:50:35.623013: W tensorflow/c/c_api.cc:300] Operation '{name:'Variable_1/Assign' id:176 op device:{requested: '', assigned: ''} def:{{{node Variable_1/Assign}} = AssignVariableOp[_has_manual_control_dependencies=true, dtype=DT_DOUBLE, validate_shape=false](Variable_1, zeros_1)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating Test error / NLL -  0\n",
      "Time elapsed -  22.012594  secs ( 0.36687657  mins)\n",
      "Warning - minibatch variance smaller than  1e-15  calculated  1  times. Consider increasing minibatch size.\n",
      "Generating discrete samples from continuous SBPS trajectory\n",
      "Evaluating Test error -  0\n",
      "Number of bounces: 1425\n",
      "percent p(acc)>1:  0.07929824561403509\n",
      "percent rejections:  0.8575\n",
      "percent negative slope:  0.1682\n",
      "total travel time:  217.07019983797858\n",
      "max trajectories:  0\n",
      "refreshments: 13\n",
      "Running pSBPS, k = 3\n",
      "Evaluating Test error / NLL -  0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-03 20:51:03.039899: W tensorflow/c/c_api.cc:300] Operation '{name:'Variable_1/Assign' id:176 op device:{requested: '', assigned: ''} def:{{{node Variable_1/Assign}} = AssignVariableOp[_has_manual_control_dependencies=true, dtype=DT_DOUBLE, validate_shape=false](Variable_1, zeros_1)}}' was changed by setting attribute after it was run by a session. This mutation will have no effect, and will trigger an error in the future. Either don't modify nodes after running them or create a new session.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating Test error / NLL -  0\n",
      "Time elapsed -  24.283445  secs ( 0.4047241  mins)\n",
      "Warning - minibatch variance smaller than  1e-15  calculated  1  times. Consider increasing minibatch size.\n",
      "Generating discrete samples from continuous SBPS trajectory\n",
      "Evaluating Test error -  0\n",
      "Number of bounces: 1098\n",
      "percent p(acc)>1:  0.061930783242258654\n",
      "percent rejections:  0.8902\n",
      "percent negative slope:  0.2002\n",
      "total travel time:  375.0688052103604\n",
      "max trajectories:  0\n",
      "refreshments: 21\n",
      "condition number  1005.3618936878329\n"
     ]
    }
   ],
   "source": [
    "# run samplers\n",
    "n_epochs=1000\n",
    "batch_size=100\n",
    "total_iter=n_epochs*(N/batch_size)\n",
    "NLL_factor = total_iter\n",
    "print('Running ' + str(n_epochs) + ' epochs (' +str(total_iter) + ' iterations) per method')\n",
    "fW_map = np.ndarray.flatten(W_map)\n",
    "\n",
    "W_start = np.random.multivariate_normal(fW_map,cov_map*100)\n",
    "k = 3\n",
    "plt_labels = []\n",
    "trajectories = []\n",
    "NLLs = []\n",
    "\n",
    "# SBPS\n",
    "k = 3\n",
    "print('Running SBPS, k = ' + str(k))\n",
    "sess.run(tf.compat.v1.initialize_all_variables())\n",
    "my_SBPS = SBPS(D,N,batch_size,k)\n",
    "NLL_SBPS_0,samples_SBPS_0 = run_sampler(my_SBPS,get_weights,set_weights,\\\n",
    "                                                       test_error,total_iter,n_epochs,NLL_factor,\\\n",
    "                                                       data,labels,batch_size,grad_calc,\\\n",
    "                                                       train_step,grad_var_calc,W_init=W_start)\n",
    "NLL_SBPS,samples_SBPS = generate_SBPS_samples(my_SBPS,get_weights,set_weights,test_error,\\\n",
    "                                                train_step,NLL_factor,W_init=W_start)\n",
    "\n",
    "\n",
    "#NLL_SBPS_0,acc_SBPS,samples_SBPS_0 = runOptimizationExplicit(my_SBPS,0,W_start)\n",
    "#NLL_SBPS,samples_SBPS = generate_SBPS_samples(my_SBPS,W_start,W,N)\n",
    "my_SBPS.print_summary()\n",
    "plt_labels.append('SBPS')\n",
    "trajectories.append(samples_SBPS)\n",
    "NLLs.append(NLL_SBPS)\n",
    "\n",
    "# pSBPS\n",
    "print('Running pSBPS, k = ' + str(k))\n",
    "sess.run(tf.compat.v1.initialize_all_variables())\n",
    "my_pSBPS = SBPS(D,N,batch_size,k)\n",
    "NLL_pSBPS_0,samples_pSBPS_0 = run_sampler(my_pSBPS,get_weights,set_weights,\\\n",
    "                                                       test_error,total_iter,n_epochs,NLL_factor,\\\n",
    "                                                       data,labels,batch_size,grad_calc,\\\n",
    "                                                       train_step,grad_var_calc,W_init=W_start,use_preconditioner=True)\n",
    "NLL_pSBPS,samples_pSBPS = generate_SBPS_samples(my_pSBPS,get_weights,set_weights,test_error,\\\n",
    "                                                train_step,NLL_factor,W_init=W_start)\n",
    "my_pSBPS.print_summary()\n",
    "plt_labels.append('pSBPS')\n",
    "trajectories.append(samples_pSBPS)\n",
    "NLLs.append(NLL_pSBPS)\n",
    "\n",
    "#assign_weights(W_map,all_weights,w_shapes) \n",
    "#NLL_map = sess.run(NLL, feed_dict={xPH: data, yPH: labels})\n",
    "cond_num = np.max(np.linalg.eig(hessian_map)[0])/float(np.min(np.linalg.eig(hessian_map)[0]))\n",
    "print('condition number ', cond_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# make plots pretty\n",
    "plt.rcParams['font.size'] = 16\n",
    "plt.rcParams['font.family']='serif'\n",
    "plt.rcParams['mathtext.default']='regular'\n",
    "\n",
    "def plot_traj():\n",
    "    # Trajectories \n",
    "    def gauss(x,y,hess,mu):\n",
    "        vec = np.asarray([x,y]) - np.asarray(mu)\n",
    "        return  -np.dot(vec,np.dot(hess,np.transpose(vec)))/2.0\n",
    "    cont_range = 50\n",
    "    x = np.linspace(W_map[0]-cont_range*np.sqrt(cov_map[0,0]), W_map[0]+cont_range*np.sqrt(cov_map[0,0]), 100)\n",
    "    y = np.linspace(W_map[1]-cont_range*np.sqrt(cov_map[1,1]), W_map[1]+cont_range*np.sqrt(cov_map[1,1]), 100)\n",
    "    X, Y = np.meshgrid(x, y)\n",
    "    zs = np.array([gauss(x,y,np.linalg.inv(cov_map[0:2,0:2]),[W_map[0],W_map[1]]) \\\n",
    "                   for x,y in zip(np.ravel(X), np.ravel(Y))])\n",
    "    Z = zs.reshape(X.shape)\n",
    "    CL = plt.contour(X, Y, Z,np.arange(-50, -1, 10),label='Laplace approx.',colors=('k'))\n",
    "    plt.clabel(CL, inline=1, fontsize=10)\n",
    "\n",
    "    # plt.title('Trajectories')\n",
    "    ptx = []\n",
    "    pty = []\n",
    "    for i in range(10):\n",
    "        tx = np.random.multivariate_normal(np.ndarray.flatten(W_map),cov_map)\n",
    "        ptx.append(tx[0])\n",
    "        pty.append(tx[1])\n",
    "\n",
    "\n",
    "    for i in range(len(trajectories)):\n",
    "        plt.plot(trajectories[i][:-1,0],trajectories[i][:-1,1],label=plt_labels[i])\n",
    "    plt.xlabel('$w_0$')\n",
    "    plt.ylabel('$w_1$')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def rotate_traj_ACF(trajectories,burnin):\n",
    "    base_change = np.linalg.eig(cov_map)[1]\n",
    "    corr2s = []\n",
    "    inds = [np.linalg.eig(cov_map)[0].argmax(),np.linalg.eig(cov_map)[0].argmin()]\n",
    "    wtrajectories = []\n",
    "    for i in range(len(trajectories)):\n",
    "        wtrajectories.append(np.dot(trajectories[i],base_change))\n",
    "    wwmap = np.squeeze(np.dot(np.transpose(W_map),base_change))\n",
    "    for j in range(2):\n",
    "        corrs3 = [] \n",
    "        for i in range(len(trajectories)): \n",
    "            #ACF\n",
    "            sig = wtrajectories[i][burnin:,inds[j]] - np.mean(wtrajectories[i][burnin:,inds[j]]) \n",
    "            corr = np.correlate(sig,sig,'full') \n",
    "            corr = corr/np.max(corr)\n",
    "            corr = corr[int(corr.shape[0]/2):] \n",
    "            corrs3.append(corr)\n",
    "        corr2s.append(corrs3)\n",
    "    return wtrajectories, corr2s, wwmap\n",
    "#[wtrajectories, corr2s, wwmap] = rotate_traj_ACF(trajectories,burnin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "def all_plots2(NLLs,plt_labels,fname,corr2s,wtrajectories,wwmap,mbs):\n",
    "    plt.rcParams['font.size'] = 13\n",
    "    plt.rcParams['font.family']='serif'\n",
    "    plt.rcParams['mathtext.default']='regular'\n",
    "    inds = [np.linalg.eig(cov_map)[0].argmax(),np.linalg.eig(cov_map)[0].argmin()]\n",
    "    \n",
    "    # NLL plot\n",
    "    from matplotlib.ticker import FormatStrFormatter,AutoMinorLocator\n",
    "    plt.subplots(figsize=(9,3))\n",
    "\n",
    "    # ACF\n",
    "    total_iter = max([len(wtrajectories[i])*mbs[i] for i in range(len(wtrajectories))])\n",
    "    j = 1\n",
    "    plt.subplot(132)\n",
    "    #plt.title('direction of largest covariance')\n",
    "    for i in range(len(wtrajectories)): \n",
    "        x = np.asarray(range(len(corr2s[0][i])))\n",
    "        plt.semilogx(mbs[i]*x,corr2s[0][i],label=plt_labels[i]) \n",
    "    plt.xlabel('lag')    \n",
    "    plt.ylabel('ACF (largest variance)')\n",
    "    plt.grid()\n",
    "    plt.axis([0,total_iter-burnin,np.min([min(c) for c in corr2s[0]]),1])\n",
    "\n",
    "    #2d traj\n",
    "    plt.subplot(131)\n",
    "    plot_traj()\n",
    "    plt.axis([-50,50,-8,1])\n",
    "    plt.legend(prop={'size':12})\n",
    "    \n",
    "    def plot_coord(j):\n",
    "        rng = 2*total_iter/5\n",
    "        std = np.sqrt(np.linalg.eig(cov_map)[0])[inds[j]]\n",
    "        for i in range(len(wtrajectories)): \n",
    "            x = np.asarray(range(len(wtrajectories[i][:int(rng/mbs[i]),:])))\n",
    "            plt.plot(mbs[i]*x,wtrajectories[i][:int(rng/mbs[i]),inds[j]])\n",
    "        plt.plot([0,rng],[wwmap[inds[j]],wwmap[inds[j]]],color='black',lw=2)\n",
    "        plt.plot([0,rng],[wwmap[inds[j]] + std,wwmap[inds[j]] + std],color='black',linestyle='--',lw=2)\n",
    "        plt.plot([0,rng],[wwmap[inds[j]] - std,wwmap[inds[j]] - std],color='black',linestyle='--',lw=2)\n",
    "        plt.xlabel('data points observed') \n",
    "        plt.locator_params(axis='x',nbins=2)\n",
    "    # Coordinates (largest)\n",
    "    plt.subplot(133)\n",
    "    plot_coord(0)\n",
    "    plt.ylabel('coordinate trace')\n",
    "\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# generate and save plots\n",
    "burnin = 1000\n",
    "[wtrajectories, corr2s, wwmap] = rotate_traj_ACF(trajectories,burnin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/mc/mjz6jzk55kvc_8bhz7vcv5_m00k0w7/T/ipykernel_76174/2347924279.py:22: UserWarning: Attempt to set non-positive xlim on a log-scaled axis will be ignored.\n",
      "  plt.axis([0,total_iter-burnin,np.min([min(c) for c in corr2s[0]]),1])\n",
      "/var/folders/mc/mjz6jzk55kvc_8bhz7vcv5_m00k0w7/T/ipykernel_76174/2216915723.py:18: UserWarning: The following kwargs were not used by contour: 'label'\n",
      "  CL = plt.contour(X, Y, Z,np.arange(-50, -1, 10),label='Laplace approx.',colors=('k'))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x300 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_plots2(NLLs,plt_labels,'prec2',corr2s,wtrajectories,wwmap,[batch_size]*len(NLLs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}