5.ddm_tiktok_vis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "# Copyright 2022 by the author(s) of CHI2023 submission \"Short-Form\n",
    "# Videos Degrade Our Capacity to Retain Intentions: Effect of Context\n",
    "# Switching On Prospective Memory\". All rights reserved.\n",
    "#\n",
    "# Use of this source code is governed by a GPLv3 license that\n",
    "# can be found in the LICENSE file.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import random, string\n",
    "from typing import List\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from scipy.stats import ks_2samp\n",
    "import tensorflow as tf\n",
    "import tensorflow_probability as tfp\n",
    "\n",
    "from pyddm import Sample, Model, Fittable\n",
    "from pyddm.models import DriftConstant, NoiseConstant, BoundConstant, OverlayNonDecision, LossRobustBIC\n",
    "from pyddm.functions import fit_adjust_model, display_model\n",
    "import pyddm.plot\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['text.usetex'] = True\n",
    "plt.rcParams['text.latex.preamble'] = r'''\\usepackage{libertine}\\usepackage{fontawesome5}\\usepackage[dvipsnames]{xcolor}'''\n",
    "plt.rcParams['ps.usedistiller'] = 'xpdf'\n",
    "\n",
    "from stats import fit_ex_gaussian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_rt = pd.read_csv('data/rt.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_ddm(df: pd.DataFrame, rt_column_name: str, correct_column_name: str, show=False) -> List[float]:\n",
    "    samples = Sample.from_pandas_dataframe(df, rt_column_name=rt_column_name, correct_column_name=correct_column_name)\n",
    "    m = Model(name='ddm',\n",
    "        drift=DriftConstant(drift=Fittable(minval=0, maxval=50)),\n",
    "        noise=NoiseConstant(noise=Fittable(minval=.5, maxval=4)),\n",
    "        bound=BoundConstant(B=Fittable(minval=.1, maxval=2)),\n",
    "        overlay=OverlayNonDecision(nondectime=Fittable(minval=0, maxval=1)),\n",
    "        dx=.001, dt=.0001, T_dur=3,\n",
    "    )\n",
    "    fit_adjust_model(samples, m, fitting_method=\"differential_evolution\", lossfunction=LossRobustBIC, verbose=False)\n",
    "    if show:\n",
    "        pyddm.plot.plot_fit_diagnostics(model=m, sample=samples)\n",
    "        display_model(m)\n",
    "    # drift, noise, bound, nondecisiontime\n",
    "    return [p.default() for p in m.get_model_parameters()]\n",
    "\n",
    "def brownian_motion(N, T, h):\n",
    "    \"\"\"\n",
    "    Simulates a Brownian motion\n",
    "    :param int N : the number of discrete steps\n",
    "    :param int T: the number of continuous time steps\n",
    "    :param float h: the variance of the increments\n",
    "    \"\"\"\n",
    "    dt = 1. * T/N                                                      # the normalizing constant\n",
    "    random_increments = np.random.normal(0.0, 1.0 * h, N)*np.sqrt(dt)  # the epsilon values\n",
    "    brownian_motion = np.cumsum(random_increments)                     # calculate the brownian motion\n",
    "    brownian_motion = np.insert(brownian_motion, 0, 0.0)               # insert the initial condition\n",
    "    return brownian_motion\n",
    "\n",
    "def drifted_brownian_motion(mu, sigma, bound, T, N=500):\n",
    "    \"\"\"Simulates a Brownian Motion with drift.\n",
    "    :param float mu: drift coefficient\n",
    "    :param float sigma: volatility coefficient\n",
    "    :param int T: number of continuous time steps\n",
    "    :param int N : number of discrete steps\n",
    "    :returns list: drifted Brownian motion\n",
    "    \"\"\"\n",
    "    while True:\n",
    "        W = brownian_motion(N, T, 1.0)\n",
    "        time_steps = np.linspace(0.0, N*(1. * T/N), N+1) # generate the time steps\n",
    "        Y = mu * time_steps + sigma * W                  # calculate the Brownian Motion with drift\n",
    "        # find the first vaule bigger than bound\n",
    "        indices = np.where(abs(Y) >= bound)\n",
    "        if len(indices[0]) > 0:\n",
    "            break\n",
    "    return time_steps[:indices[0][0]], Y[:indices[0][0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_diffusion(ax1, ax2, ax3, drift, noise, bound, non_decision_time, ground_truth, color_simulate='steelblue', color_true='red'):\n",
    "    colors = sns.color_palette('vlag', as_cmap=False, n_colors=10)\n",
    "    c1 = colors[0]\n",
    "    c2 = colors[-1]\n",
    "    color_simulate = c1\n",
    "    color_true = c2\n",
    "\n",
    "    Tmax = 3\n",
    "\n",
    "    # configure x limit\n",
    "    ax1.set_xlim(0, Tmax)\n",
    "    ax2.set_xlim(0, Tmax)\n",
    "    ax3.set_xlim(0, Tmax)\n",
    "\n",
    "    # draw ground truth\n",
    "    rts_true = ground_truth[ground_truth.correct == True].rt\n",
    "    ax1.hist(rts_true, bins=50, color=color_simulate, alpha=.25)\n",
    "    rts_false = ground_truth[ground_truth.correct == False].rt\n",
    "    ax3.hist(rts_false, bins=50, color=color_true, alpha=.25)\n",
    "    correct_grountruth = np.array([t==True for t in ground_truth.correct.values])\n",
    "    ax1.text(.99, .9,  f'accuracy: {correct_grountruth.mean()*100:.2f}\\%',  ha='right', va='top',    transform=ax1.transAxes, fontsize=8)\n",
    "    ax3.text(.99, .05, f'error: {100 - correct_grountruth.mean()*100:.2f}\\%', ha='right', va='bottom', transform=ax3.transAxes, fontsize=8)\n",
    "\n",
    "    # make sure top and bottom distributions have the same y-axis scale.\n",
    "    y1max = ax1.get_ylim()[1]\n",
    "    y3max = ax3.get_ylim()[1]\n",
    "    ymax = max(y1max,y3max)\n",
    "    ax1.set(ylim=(0, ymax))\n",
    "    ax3.set(ylim=(0, ymax))\n",
    "    ax3.invert_yaxis()\n",
    "\n",
    "    # setup DDM bound\n",
    "    ax2.set(ylim=(-bound, bound))\n",
    "\n",
    "    # simulate DDM\n",
    "    trials = [drifted_brownian_motion(drift, noise, bound, Tmax) for _ in range(200)]\n",
    "    correct = np.array([t[-1] > 0 for _, t in trials])\n",
    "\n",
    "    hist_correct = []\n",
    "    hist_error   = []\n",
    "    upDrawed = False\n",
    "    downDrawed = False\n",
    "    for i, v in enumerate(correct):\n",
    "        x, y = trials[i]\n",
    "        if v:\n",
    "            draw = y > -bound/4\n",
    "            if False not in draw:\n",
    "                ax2.plot(non_decision_time+x, y, alpha=.15, c=color_simulate, zorder=0, lw=0.3)\n",
    "                if 0.5 < x[-1] < 1 and not upDrawed:\n",
    "                    ax2.plot(non_decision_time+x, y, alpha=1, c=color_simulate, lw=1)\n",
    "                    upDrawed = True\n",
    "            hist_correct.append(x[-1])\n",
    "        else:\n",
    "            draw = y < bound/4\n",
    "            if False not in draw:\n",
    "                ax2.plot(non_decision_time+x, y, alpha=.15, c=color_true, zorder=0, lw=0.3)\n",
    "                if 0.5 < x[-1] < 1 and not downDrawed:\n",
    "                    ax2.plot(non_decision_time+x, y, alpha=1, c=color_true, lw=1)\n",
    "                    downDrawed = True\n",
    "            hist_error.append(x[-1])\n",
    "\n",
    "    # Draw correct key press distribution.\n",
    "    # Fit ex-gaussian until the error is below 1%\n",
    "    corrects = non_decision_time+np.array(hist_correct)\n",
    "    for _ in range(10):\n",
    "        loc, scale, rate = fit_ex_gaussian(corrects, progress=True)\n",
    "        y_pred = np.random.exponential(scale=1/rate, size=100) + np.random.normal(loc=loc, scale=scale, size=100)\n",
    "        r = ks_2samp(corrects, y_pred)\n",
    "        if r.pvalue >= 0.5:\n",
    "            break\n",
    "    p_y = tfp.distributions.ExponentiallyModifiedGaussian(loc=loc, scale=scale, rate=rate)\n",
    "    x_t = np.linspace(0, Tmax, 500)\n",
    "    y_line = p_y.prob(x_t)\n",
    "    ax1.plot(x_t, y_line * y1max/2, label=\"y_estimate\", color='steelblue')\n",
    "\n",
    "    # Same here.\n",
    "    errors   = non_decision_time+np.array(hist_error)\n",
    "    for _ in range(10):\n",
    "        try:\n",
    "            loc, scale, rate = fit_ex_gaussian(errors, progress=True)\n",
    "            y_pred = np.random.exponential(scale=1/rate, size=100) + np.random.normal(loc=loc, scale=scale, size=100)\n",
    "            r = ks_2samp(corrects, y_pred)\n",
    "            if r.pvalue >= 0.5:\n",
    "                break\n",
    "        except:\n",
    "            pass\n",
    "    p_y = tfp.distributions.ExponentiallyModifiedGaussian(loc=loc, scale=scale, rate=rate)\n",
    "    x_t = np.linspace(0, Tmax, 500)\n",
    "    y_line = p_y.prob(x_t)\n",
    "    ax3.plot(x_t, y_line * y3max/2, label=\"y_estimate\", color=color_true)\n",
    "\n",
    "    # Draw non-decision time and decision bound.\n",
    "    ax2.axhline(y=bound, xmin=0, xmax=3, c='black', lw=1, linestyle='--')\n",
    "    ax2.axhline(y=0, xmin=0, xmax=non_decision_time/3, c='black', lw=1, linestyle='--') # why this has to divide by 3?\n",
    "    ax2.axhline(y=-bound, xmin=0, xmax=3, c='black', lw=1, linestyle='--')\n",
    "    ax2.text(2.98, bound-0.3,  f'decision upper bound $B={bound:.2f}$',  ha='right', va='top', fontsize=8)\n",
    "    ax2.text(2.98, -bound+0.5, f'decision lower bound $B={-bound:.2f}$',  ha='right', va='top', fontsize=8)\n",
    "    ax2.text(0.02, -0.3, f'non-decision\\ntime~$t={non_decision_time*1000:.0f}$ms', ha='left', va='bottom', fontsize=8)\n",
    "\n",
    "    ax2.text(0.02, -bound+0.25, f'drift~~$\\mu={drift:.2f}$\\n variance~$\\sigma={noise:.2f}$', ha='left', va='bottom', c='black', fontsize=8)\n",
    "\n",
    "    # Draw simulated distribution\n",
    "    ax1.hist(corrects, bins=50, color=color_simulate)\n",
    "    ax3.hist(errors, bins=50, color=color_true)\n",
    "\n",
    "    # annotate axes labels.\n",
    "    ax3.set_xticks(ax3.get_xticks().tolist())\n",
    "    ax3.set_xticklabels([f'{x*1000:.0f}' for x in ax3.get_xticks()])\n",
    "    ax2.set_yticks(ax2.get_yticks().tolist())\n",
    "    ax2.set_yticklabels([f'{x:.0f}' for x in ax2.get_yticks()])\n",
    "\n",
    "    ax1.set(ylabel='Counts')\n",
    "    ax2.set(ylabel='Decision Process')\n",
    "    ax3.set(xlabel='RTs (ms)', ylabel='Counts')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_and_draw_ddm(task, interrupt, interruptName, measure, seed=42):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    tf.random.set_seed(seed)\n",
    "    ddm_data = df_rt[(df_rt.task == task) & (df_rt.success == True) & (df_rt.interrupt == interrupt) & (df_rt.measure == measure)]\n",
    "    print('fitting:', task, interrupt, measure)\n",
    "    params = fit_ddm(ddm_data, 'rt', 'correct', show=False)\n",
    "    f, (ax1, ax2, ax3) = plt.subplots(3, sharex=True, gridspec_kw={'height_ratios': (.25, .5, .25)})\n",
    "    plot_diffusion(ax1, ax2, ax3, params[0], params[1], params[2], params[3], ddm_data)\n",
    "    ax1.set_title(f'Fitted DDM for {interruptName} {string.capwords(measure)}-interruption RTs')\n",
    "    f = f'figures/fig6_ddm_{task}_{interrupt}_{measure}_{seed}.pdf'\n",
    "    print('saving to: ', f)\n",
    "    plt.savefig(f, dpi=300, bbox_inches='tight')\n",
    "    plt.cla()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fitting: PM tiktok pre\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Info: Params [1.46260285 1.88944687 1.93592873 0.46076796] gave 457.12785448071037\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e642a8a000d41f68aea022fb4bee892",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-11-30 19:45:55.455686: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17b3ae1f0> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17b3ae1f0>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17b3ae1f0> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17b3ae1f0>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "75599dd5ef634abba224ed3783be889c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17f0dc9d0> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17f0dc9d0>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17f0dc9d0> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17f0dc9d0>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e8d6f80fcf74fd1ad1953250e5be094",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17fd2a820> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17fd2a820>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17fd2a820> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17fd2a820>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "72999ab39bf143819418f8b656322363",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x298e1d280> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x298e1d280>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x298e1d280> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x298e1d280>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "saving to:  figures/ddm_PM_tiktok_pre_42.pdf\n",
      "fitting: PM tiktok post\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Info: Params [0.         2.34798562 1.71167503 0.68069025] gave 461.4626110965323\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4f7959898f0145f382f391b98bac2fb8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x299bb8670> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x299bb8670>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x299bb8670> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x299bb8670>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "671b1d5f210c40f2ac55e2da7cdd65d2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17e389c10> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17e389c10>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x17e389c10> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x17e389c10>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd2cf1ed872d408caf6897ba7706c324",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|           0/500 ETA: ?s,  ?epochs/s"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning:tensorflow:AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x29982d3a0> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x29982d3a0>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "WARNING: AutoGraph could not transform <function fit_ex_gaussian.<locals>.<lambda> at 0x29982d3a0> and will run it as-is.\n",
      "Cause: could not parse the source code of <function fit_ex_gaussian.<locals>.<lambda> at 0x29982d3a0>: no matching AST found among candidates:\n",
      "# coding=utf-8\n",
      "lambda y, distr: -distr.log_prob(y)\n",
      "# coding=utf-8\n",
      "lambda t: tfp.distributions.ExponentiallyModifiedGaussian(loc=t[..., :1], scale=0.001 + tf.math.softplus(0.05 * t[..., 1:]), rate=tf.math.softplus(t[..., 2:]))\n",
      "To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert\n",
      "saving to:  figures/ddm_PM_tiktok_post_42.pdf\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "seed = 42\n",
    "task = 'PM'\n",
    "\n",
    "fit_and_draw_ddm('PM', 'tiktok', 'TikTok', 'pre', seed)\n",
    "fit_and_draw_ddm('PM', 'tiktok', 'TikTok', 'post', seed)\n",
    "\n",
    "# fit_and_draw_ddm('PM', 'twitter', 'Twitter', 'pre', seed)\n",
    "# fit_and_draw_ddm('PM', 'twitter', 'Twitter', 'post', seed)\n",
    "\n",
    "# fit_and_draw_ddm('PM', 'youtube', 'YouTube', 'pre', seed)\n",
    "# fit_and_draw_ddm('PM', 'youtube', 'YouTube', 'post', seed)\n",
    "\n",
    "# fit_and_draw_ddm('PM', 'rest', 'Rest', 'pre', seed)\n",
    "# fit_and_draw_ddm('PM', 'rest', 'Rest', 'post', seed)"
   ]
  }
 ],
 "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.8.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}