feat: added lots of citations and slowly finishing the introduction

author: mjkwiatkowski <mati.rewa@gmail.com> 2026-05-17 14:21:09 +0200
committer: mjkwiatkowski <mati.rewa@gmail.com> 2026-05-17 14:21:09 +0200
commit: a5a140c6286e8b113ca8d371f88e3ed54e731cea (patch)
tree: cd648c36df09d30c217166865a81a0c4e523932b /datasets/Talluri2021/4.response time experiment.ipynb
parent: a4102d0252236e85b2813160b4b11e3a19a00d62 (diff)
1 files changed, 543 insertions, 0 deletions
diff --git a/datasets/Talluri2021/4.response time experiment.ipynb b/datasets/Talluri2021/4.response time experiment.ipynb
new file mode 100644
index 0000000..3c63e3b
--- /dev/null
+++ b/datasets/Talluri2021/4.response time experiment.ipynb
@@ -0,0 +1,543 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import random\n",
+    "import gc\n",
+    "import time\n",
+    "import pandas as pd\n",
+    "from plotnine import *\n",
+    "from numpy.random import weibull"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "31536000\n",
+      "15768000.0\n",
+      "{0: 14995272.0, 1: 749658.0, 2: 22542.0, 3: 508.0, 4: 9.0} 10.926686001093943\n"
+     ]
+    }
+   ],
+   "source": [
+    "def runsim(num_reqs, failure_prob_thresh, num_trials=1):\n",
+    "    max_retries = 3\n",
+    "    successful_requests = np.full((num_reqs, num_trials), False)\n",
+    "    current_retries = np.full((num_reqs, num_trials), 0, dtype=np.uint8)\n",
+    "    all_retries = np.full((num_reqs, num_trials), 0, dtype=np.uint8)\n",
+    "    \n",
+    "    # run till all requests succeed or max retries at all levels are exhausted\n",
+    "    while (not np.all(successful_requests)) and np.all(current_retries < max_retries+1):\n",
+    "        random_nums = np.random.random_sample(size=(num_reqs, num_trials))\n",
+    "        successful_this_round = random_nums >= np.repeat(np.transpose([failure_prob_thresh]), num_trials, axis=1)\n",
+    "#         print(successful_this_round)\n",
+    "        \n",
+    "        valid_requests_this_round = ~successful_requests & (current_retries < max_retries+1)\n",
+    "        \n",
+    "        \n",
+    "        success_intermediate = (valid_requests_this_round & successful_this_round) | successful_requests\n",
+    "        (failure_rows, failure_columns) = np.nonzero(~success_intermediate)\n",
+    "        \n",
+    "        # So, if requests fail at level 2 and 3. Only the failure at 2 is counted\n",
+    "        # We can do this because failure_columns is SORTED in column order\n",
+    "        # take care: unique rows does not contain all rows. There are many rows without any failures\n",
+    "        (unique_rows, unique_indices) = np.unique(failure_rows, return_index=True)\n",
+    "        unique_rows_first_column = failure_columns[unique_indices]\n",
+    "        \n",
+    "        # Update retries\n",
+    "        current_retries[unique_rows, unique_rows_first_column] += 1\n",
+    "        all_retries[unique_rows, unique_rows_first_column] += 1\n",
+    "        \n",
+    "        repeated_unique_rows_first_column = np.repeat(np.transpose([unique_rows_first_column]), num_trials, axis=1)\n",
+    "        (row_indices, column_indices) = np.indices((num_reqs, num_trials))\n",
+    "        mask = np.full((num_reqs, num_trials), np.iinfo(np.int32).max, dtype=np.int32)\n",
+    "        mask[unique_rows] = repeated_unique_rows_first_column\n",
+    "#         print(mask)\n",
+    "        \n",
+    "        successful_requests = column_indices < mask\n",
+    "\n",
+    "        # Rollback to previous level if max retries for this level has been reached\n",
+    "        rollback_mask = current_retries == max_retries\n",
+    "        (exhausted_retries_rows, exhausted_retries_columns) = np.nonzero(rollback_mask)\n",
+    "        exhausted_retries_prev_columns = exhausted_retries_columns - 1\n",
+    "#         print(exhausted_retries_prev_columns)\n",
+    "        valid_prev_col = exhausted_retries_prev_columns >= 0\n",
+    "#         print(valid_prev_col)\n",
+    "        can_be_retried_again_rows = exhausted_retries_rows[valid_prev_col]\n",
+    "        can_be_retried_again_columns = exhausted_retries_columns[valid_prev_col]\n",
+    "        \n",
+    "        exhausted_retries_prev_columns[~valid_prev_col] = 0\n",
+    "        successful_requests[exhausted_retries_rows, exhausted_retries_prev_columns] = False\n",
+    "        current_retries[can_be_retried_again_rows, can_be_retried_again_columns] = 0\n",
+    "    \n",
+    "    # https://lup.lub.lu.se/search/ws/files/5764781/4814056.pdf\n",
+    "    # Magnitude of sin from above paper\n",
+    "    sin_input = np.linspace(-np.pi, np.pi, 24*60*60)\n",
+    "    sin_scaler = np.tile((np.sin(sin_input) + 1) / 2, 365) # Sin min magnitude 0, max 1, for 365 days\n",
+    "    \n",
+    "    results = {}\n",
+    "    overall_successful_requests = np.all(successful_requests, axis=1)\n",
+    "    retries_per_request = np.sum(all_retries, axis=1)\n",
+    "    consolidated_retries = retries_per_request[overall_successful_requests]\n",
+    "    filtered_sin_scaler = sin_scaler[overall_successful_requests]\n",
+    "#     print(consolidated_retries.shape)\n",
+    "#     print(filtered_sin_scaler.shape)\n",
+    "#     return (True, True)\n",
+    "    unique_retries = np.unique(consolidated_retries)\n",
+    "    for entry in unique_retries:\n",
+    "        results[entry] = np.round(np.sum(filtered_sin_scaler[consolidated_retries == entry]))\n",
+    "#     print(np.transpose(successful_requests))\n",
+    "    scaled_unsuccessful_requests = ~overall_successful_requests * sin_scaler\n",
+    "    return (results, np.sum(scaled_unsuccessful_requests))\n",
+    "\n",
+    "sin_input = np.linspace(-np.pi, np.pi, 24*60*60)\n",
+    "per_day_sin_scaler = (np.sin(sin_input) + 1) / 2\n",
+    "num_reqs = 365*24*60*60\n",
+    "scaled_num_reqs = np.sum(per_day_sin_scaler) * 365\n",
+    "print(num_reqs)\n",
+    "print(np.round(scaled_num_reqs))\n",
+    "# 20min is outage report granularity\n",
+    "num_20min_chunks = num_reqs // (20*60)\n",
+    "failure_probabilities = np.repeat(0.01, num_20min_chunks)\n",
+    "failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n",
+    "\n",
+    "(results, failed_reqs) = runsim(num_reqs, np.transpose(failure_prob_thresh), num_trials=5)\n",
+    "# (results, failed_reqs) = runsim(10, np.repeat(0.5, 10), num_trials=5)\n",
+    "print(results, failed_reqs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{0: 28523119} 3012881\n"
+     ]
+    }
+   ],
+   "source": [
+    "def runsim_fanout(num_reqs, failure_prob_thresh, fanout=1):\n",
+    "    max_retries = 3\n",
+    "    successful_requests = np.full((num_reqs, fanout), False)\n",
+    "    current_retries = np.full((num_reqs, fanout), 0, dtype=np.uint8)\n",
+    "    \n",
+    "    # run till all requests succeed or max retries at all levels are exhausted\n",
+    "    while (not np.all(successful_requests)) and np.all(current_retries < max_retries+1):\n",
+    "        random_nums = np.random.random_sample(size=(num_reqs, fanout))\n",
+    "        successful_this_round = random_nums >= np.repeat(np.transpose([failure_prob_thresh]), fanout, axis=1)\n",
+    "        \n",
+    "        valid_requests_this_round = ~successful_requests & (current_retries < max_retries+1)\n",
+    "        successful_valid = valid_requests_this_round & successful_this_round\n",
+    "        \n",
+    "        # Update retries\n",
+    "        current_retries[~successful_valid] += 1\n",
+    "        \n",
+    "        successful_requests = successful_requests | successful_valid\n",
+    "        break\n",
+    "    \n",
+    "    results = {}\n",
+    "    overall_successful_requests = np.all(successful_requests, axis=1)\n",
+    "    consolidated_retries = np.sum(current_retries, axis=1)[overall_successful_requests]\n",
+    "    unique_retries = np.unique(consolidated_retries)\n",
+    "    for entry in unique_retries:\n",
+    "        results[entry] = np.sum(consolidated_retries == entry)\n",
+    "    return (results, np.sum(~overall_successful_requests))\n",
+    "\n",
+    "\n",
+    "num_reqs = 365*24*60*60\n",
+    "# 20min is outage report granularity\n",
+    "num_20min_chunks = num_reqs // (20*60)\n",
+    "failure_probabilities = np.repeat(0.01, num_20min_chunks)\n",
+    "failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n",
+    "\n",
+    "(results, failed_reqs) = runsim_fanout(num_reqs, np.transpose(failure_prob_thresh), fanout=10)\n",
+    "# (results, failed_reqs) = runsim_fanout(10, np.repeat(0.01, 10), fanout=10)\n",
+    "print(results, failed_reqs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_reqs = 365*24*60*60\n",
+    "# 20min is outage report granularity\n",
+    "num_20min_chunks = num_reqs // (20*60)\n",
+    "num_iterations = 1\n",
+    "results = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for iteration in range(num_iterations):\n",
+    "    num_20min_chunks = num_reqs // (20*60)\n",
+    "    failure_probabilities = np.repeat(0.01, num_20min_chunks)\n",
+    "    failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n",
+    "    \n",
+    "#     (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh)\n",
+    "#     results.append(pd.DataFrame({\n",
+    "#         'vendor': 'uniform',\n",
+    "#         'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "#         'retries': list(final_counts.keys()) + [100],\n",
+    "#         'iteration': iteration,\n",
+    "#         'experiment': 'monolith'\n",
+    "#     }))\n",
+    "    \n",
+    "    (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh, num_trials=5)\n",
+    "    results.append(pd.DataFrame({\n",
+    "        'vendor': 'uniform',\n",
+    "        'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "        'retries': list(final_counts.keys()) + [100],\n",
+    "        'iteration': iteration,\n",
+    "        'experiment': 'deep chain'\n",
+    "    }))\n",
+    "    \n",
+    "#     (final_counts, failed_reqs) = runsim_fanout(num_reqs, failure_prob_thresh, fanout=10)\n",
+    "#     results.append(pd.DataFrame({\n",
+    "#         'vendor': 'uniform',\n",
+    "#         'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "#         'retries': list(final_counts.keys()) + [100],\n",
+    "#         'iteration': iteration,\n",
+    "#         'experiment': 'fanout'\n",
+    "#     }))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[    vendor      reqs  retries  iteration experiment\n",
+       " 0  uniform  28382785        0          0   monolith\n",
+       " 1  uniform   2837362        1          0   monolith\n",
+       " 2  uniform    284158        2          0   monolith\n",
+       " 3  uniform     28516        3          0   monolith\n",
+       " 4  uniform      3179      100          0   monolith,\n",
+       "     vendor      reqs  retries  iteration experiment\n",
+       " 0  uniform  28387324        0          0   monolith\n",
+       " 1  uniform   2834446        1          0   monolith\n",
+       " 2  uniform    282792        2          0   monolith\n",
+       " 3  uniform     28385        3          0   monolith\n",
+       " 4  uniform      3053      100          0   monolith,\n",
+       "     vendor      reqs  retries  iteration  experiment\n",
+       " 0  uniform  18618827        0          0  deep chain\n",
+       " 1  uniform   9311619        1          0  deep chain\n",
+       " 2  uniform   2795059        2          0  deep chain\n",
+       " 3  uniform    652424        3          0  deep chain\n",
+       " 4  uniform    158071      100          0  deep chain,\n",
+       "     vendor      reqs  retries  iteration experiment\n",
+       " 0  uniform  10993887        0          0     fanout\n",
+       " 1  uniform  20542113      100          0     fanout]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "or_events = pd.read_parquet('./outage_report_2019-20').reset_index(drop=True)\n",
+    "filtered_or_events = or_events[(or_events['vendor'] != '') & (or_events['vendor'] != 'overview')].copy()\n",
+    "filtered_or_events = filtered_or_events.drop_duplicates(subset=['vendor', 'event_time', 'status_code'])\n",
+    "# Combine events with the same event_time, but different status_code with max\n",
+    "filtered_or_events = filtered_or_events.groupby(['vendor', 'event_time'])['status_code'].max().reset_index()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sin_input = np.linspace(-np.pi, np.pi, 24*3)\n",
+    "sin_scaler = np.tile((np.sin(sin_input) + 1) / 2, 365) # Sin min magnitude 0, max 1, for 265 days\n",
+    "for iteration in range(num_iterations):\n",
+    "    vendor = 'instagram'\n",
+    "    vendor_df = filtered_or_events[filtered_or_events['vendor'] == vendor].sort_values('event_time').reset_index(drop=True).loc[:num_20min_chunks-1]\n",
+    "    scaled_reports = sin_scaler * vendor_df['status_code']\n",
+    "    failure_fraction = scaled_reports / scaled_reports.max()\n",
+    "    failure_prob_thresh = np.repeat(failure_fraction, 20*60)\n",
+    "    \n",
+    "#     (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh)\n",
+    "#     results.append(pd.DataFrame({\n",
+    "#         'vendor': vendor,\n",
+    "#         'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "#         'retries': list(final_counts.keys()) + [100],\n",
+    "#         'iteration': iteration,\n",
+    "#         'experiment': 'monolith'\n",
+    "#     }))\n",
+    "    \n",
+    "    (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh, num_trials=5)\n",
+    "    results.append(pd.DataFrame({\n",
+    "        'vendor': vendor,\n",
+    "        'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "        'retries': list(final_counts.keys()) + [100],\n",
+    "        'iteration': iteration,\n",
+    "        'experiment': 'deep chain'\n",
+    "    }))\n",
+    "    \n",
+    "#     (final_counts, failed_reqs) = runsim_fanout(num_reqs, failure_prob_thresh, fanout=10)\n",
+    "#     results.append(pd.DataFrame({\n",
+    "#         'vendor': vendor,\n",
+    "#         'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "#         'retries': list(final_counts.keys()) + [100],\n",
+    "#         'iteration': iteration,\n",
+    "#         'experiment': 'fanout'\n",
+    "#     }))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "structures_experiment_results = pd.concat(results)\n",
+    "structures_experiment_results.to_csv('./experiment_results/long_chain_results_sin1.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "only_const_results = []\n",
+    "# for iteration in range(num_iterations):\n",
+    "iteration = 1\n",
+    "for prob in [0.01, 0.1, 0.25, 0.5, 0.75]:\n",
+    "    num_20min_chunks = num_reqs // (20*60)\n",
+    "    failure_probabilities = np.repeat(prob, num_20min_chunks)\n",
+    "    failure_prob_thresh = np.repeat(failure_probabilities, 20*60)\n",
+    "\n",
+    "    (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh)\n",
+    "    only_const_results.append(pd.DataFrame({\n",
+    "        'vendor': 'uniform',\n",
+    "        'prob': prob,\n",
+    "        'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "        'retries': list(final_counts.keys()) + [100],\n",
+    "        'iteration': iteration,\n",
+    "        'experiment': 'monolith'\n",
+    "    }))\n",
+    "\n",
+    "    (final_counts, failed_reqs) = runsim(num_reqs, failure_prob_thresh, num_trials=5)\n",
+    "    only_const_results.append(pd.DataFrame({\n",
+    "        'vendor': 'uniform',\n",
+    "        'prob': prob,\n",
+    "        'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "        'retries': list(final_counts.keys()) + [100],\n",
+    "        'iteration': iteration,\n",
+    "        'experiment': 'deep chain'\n",
+    "    }))\n",
+    "\n",
+    "    (final_counts, failed_reqs) = runsim_fanout(num_reqs, failure_prob_thresh, fanout=10)\n",
+    "    only_const_results.append(pd.DataFrame({\n",
+    "        'vendor': 'uniform',\n",
+    "        'prob': prob,\n",
+    "        'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "        'retries': list(final_counts.keys()) + [100],\n",
+    "        'iteration': iteration,\n",
+    "        'experiment': 'fanout'\n",
+    "    }))\n",
+    "        \n",
+    "const_results_df = pd.concat(only_const_results)\n",
+    "const_results_df.to_csv('./experiment_results/const_experiment_results_1.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# highest failures for instagram are on 13th june 2019. Confirmed that an instagram outage occurred on that date\n",
+    "vendor_results = []\n",
+    "vendors = filtered_or_events['vendor'].unique()\n",
+    "for vendor in vendors:\n",
+    "    vendor_df = filtered_or_events[filtered_or_events['vendor'] == vendor].sort_values('event_time').reset_index(drop=True).loc[:num_20min_chunks-1]\n",
+    "    vendor_df['failure_fraction'] = vendor_df['status_code'] / vendor_df['status_code'].max()\n",
+    "    for iteration in range(1):\n",
+    "        (final_counts, failed_reqs) = runsim(num_reqs, np.repeat(vendor_df['failure_fraction'].values, 20*60))\n",
+    "        vendor_results.append(pd.DataFrame({\n",
+    "            'vendor': vendor,\n",
+    "            'reqs': list(final_counts.values()) + [failed_reqs],\n",
+    "            'retries': list(final_counts.keys()) + [100],\n",
+    "            'iteration': iteration\n",
+    "        }))\n",
+    "vendors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vendor_results_df = pd.concat(vendor_results).reset_index(drop=True)\n",
+    "vendor_results_df = vendor_results_df[(vendor_results_df['iteration'] == 0) & (vendor_results_df['retries'] != 0)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vendor_results_df['fraction'] = vendor_results_df['reqs'] / num_reqs\n",
+    "vendor_results_df['color'] = 'trace'\n",
+    "vendor_results_df.loc[vendor_results_df['vendor'] == 'uniform', 'color'] = 'uniform'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:719: PlotnineWarning: Saving 6.4 x 4.8 in image.\n",
+      "/home/sacheendra/miniconda3/envs/thesis/lib/python3.8/site-packages/plotnine/ggplot.py:722: PlotnineWarning: Filename: traces_vs_uniform-uniform_workload.png\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<ggplot: (8757981852757)>"
+      ]
+     },
+     "execution_count": 116,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "plt = ggplot(vendor_results_df) +\\\n",
+    "    geom_line(aes(x='retries', y='fraction', group='vendor', color='color'), size=1) +\\\n",
+    "    scale_y_log10() +\\\n",
+    "    xlab('num_retries')\n",
+    "\n",
+    "plt.save('traces_vs_uniform-uniform_workload.png', dpi=300)\n",
+    "plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 140,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<ggplot: (8757963694102)>"
+      ]
+     },
+     "execution_count": 140,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = np.linspace(-np.pi, np.pi, 24*3)\n",
+    "y = np.tile(np.sin(x) + 1, 365) / 2\n",
+    "\n",
+    "ggplot()+\\\n",
+    "    geom_line(aes(x=range(len(y))[:10000], y=y[:10000]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.17453292519943295"
+      ]
+     },
+     "execution_count": 128,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "2*np.pi / (12)"
+   ]
+  }
+ ],
+ "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.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
author	mjkwiatkowski <mati.rewa@gmail.com>	2026-05-17 14:21:09 +0200
committer	mjkwiatkowski <mati.rewa@gmail.com>	2026-05-17 14:21:09 +0200
commit	a5a140c6286e8b113ca8d371f88e3ed54e731cea (patch)
tree	cd648c36df09d30c217166865a81a0c4e523932b /datasets/Talluri2021/4.response time experiment.ipynb
parent	a4102d0252236e85b2813160b4b11e3a19a00d62 (diff)