between_the_lines/user_study_analysis/section6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import json\n",
    "import copy\n",
    "import json\n",
    "from tqdm import tqdm\n",
    "import pickle\n",
    "import logging\n",
    "import math\n",
    "import matplotlib\n",
    "from re import S\n",
    "import collections\n",
    "from hmmviz import TransGraph\n",
    "from scipy.stats.stats import pearsonr  \n",
    "matplotlib.rcParams['pdf.fonttype'] = 42\n",
    "matplotlib.rcParams['ps.fonttype'] = 42\n",
    "plt.rc('text', usetex=True)\n",
    "plt.rc('font', family='sans-serif')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "with open('../data/data_labeled_study.pkl', 'rb') as f:\n",
    "    logs_by_user_session_labeled = pickle.load(f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 6.1: Time Spent in various CUPSs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For figures 6a and 6c, please see the notebooks viz_draw.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Figure 6b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "all_states_continuous = []\n",
    "all_states_list = []\n",
    "all_times_list = []\n",
    "\n",
    "all_times_continuous = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'Edditing Last Suggestion (X)':\n",
    "            states[j] = 'Editing Last Suggestion (X)'\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = states[0]\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        if states[i] != last_state:\n",
    "            states_continuous.append(last_state)\n",
    "            last_state = states[i]\n",
    "            times_continuous.append(times_cumalitive)\n",
    "            times_cumalitive = times[i]\n",
    "        else:\n",
    "            times_cumalitive += times[i]\n",
    "    states_continuous.append(last_state)\n",
    "    times_continuous.append(times_cumalitive)\n",
    "    \n",
    "    all_states_list.extend(states)\n",
    "    all_times_list.extend(times)\n",
    "    all_states_continuous.extend(states_continuous)\n",
    "    all_times_continuous.extend(times_continuous)\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Averaged Across Users \n",
      " \n",
      "\n",
      " Editing Written Code(C)  4.28\n",
      " Thinking About New Code To Write (F)  10.91\n",
      " Writing New Functionality (Z)  14.05\n",
      " Deferring Thought For Later (D)  1.39\n",
      " Looking up Documentation (N)  7.45\n",
      " Debugging/Testing Code (H)  11.31\n",
      " Not Thinking (S)  0.00\n",
      " Waiting For Suggestion (G)  4.20\n",
      " Editing Last Suggestion (X)  11.90\n",
      " Prompt Crafting (V)  11.56\n",
      " Writing Documentation (B)  0.53\n",
      " Thinking/Verifying Suggestion (A)  22.40\n"
     ]
    }
   ],
   "source": [
    "states_unique = list(set(all_states_continuous))\n",
    "# for each session, count how many times each state is used\n",
    "\n",
    "states_count = [[0 for i in range(len(states_unique))] for _ in range(len(all_states))]\n",
    "for i in range(len(all_states)):\n",
    "    for j in range(len(all_states[i])):\n",
    "        states_count[i][states_unique.index(all_states[i][j])] += all_times[i][j]\n",
    "# normalize\n",
    "states_count = [[i/sum(states_count_single)*100 for i in states_count_single] for states_count_single in states_count]\n",
    "averaged_over_users = np.mean(states_count, axis=0)\n",
    "# print\n",
    "print('Averaged Across Users \\n \\n')\n",
    "for i in range(len(states_unique)):\n",
    "    print(f' {states_unique[i]}  {averaged_over_users[i]:.2f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Averaged Across All Sessions \n",
      " \n",
      "\n",
      " Editing Written Code(C)  4.46\n",
      " Thinking About New Code To Write (F)  12.77\n",
      " Writing New Functionality (Z)  13.34\n",
      " Deferring Thought For Later (D)  1.34\n",
      " Looking up Documentation (N)  7.38\n",
      " Debugging/Testing Code (H)  11.56\n",
      " Not Thinking (S)  0.01\n",
      " Waiting For Suggestion (G)  4.59\n",
      " Editing Last Suggestion (X)  11.22\n",
      " Prompt Crafting (V)  11.08\n",
      " Writing Documentation (B)  0.44\n",
      " Thinking/Verifying Suggestion (A)  21.82\n"
     ]
    }
   ],
   "source": [
    "states_unique = list(set(all_states_continuous))\n",
    "# for each session, count how many times each state is used\n",
    "states_count = [0 for i in range(len(states_unique))]\n",
    "states_freq = {}\n",
    "for i in range(len(all_states)):\n",
    "    for j in range(len(all_states[i])):\n",
    "        states_count[states_unique.index(all_states[i][j])] += all_times[i][j]\n",
    "# normalize\n",
    "states_count = [i/sum(states_count)*100 for i in states_count]\n",
    "print('Averaged Across All Sessions \\n \\n')\n",
    "for i in range(len(states_count)):\n",
    "    print(f' {states_unique[i]}  {states_count[i]:.2f}')\n",
    "    states_freq[states_unique[i]] = states_count[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " state Thinking/Verifying Suggestion (A) avg time 5.29 median time 1.22 std time 11.87\n",
      " state Looking up Documentation (N) avg time 75.84 median time 62.78 std time 75.20\n",
      " state Prompt Crafting (V) avg time 1.91 median time 0.26 std time 6.86\n",
      " state Thinking About New Code To Write (F) avg time 8.27 median time 0.86 std time 22.61\n",
      " state Writing New Functionality (Z) avg time 3.03 median time 0.46 std time 8.19\n",
      " state Editing Last Suggestion (X) avg time 9.82 median time 1.14 std time 20.91\n",
      " state Debugging/Testing Code (H) avg time 13.60 median time 1.30 std time 24.57\n",
      " state Editing Written Code(C) avg time 7.16 median time 0.60 std time 21.09\n",
      " state Waiting For Suggestion (G) avg time 4.18 median time 1.03 std time 11.09\n",
      " state Writing Documentation (B) avg time 3.98 median time 0.86 std time 9.56\n",
      " state Deferring Thought For Later (D) avg time 2.41 median time 1.31 std time 3.15\n",
      " state Not Thinking (S) avg time 1.19 median time 1.19 std time 0.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hussein/miniconda3/envs/hussein/lib/python3.9/site-packages/numpy/core/_methods.py:264: RuntimeWarning: Degrees of freedom <= 0 for slice\n",
      "  ret = _var(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
      "/home/hussein/miniconda3/envs/hussein/lib/python3.9/site-packages/numpy/core/_methods.py:256: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    }
   ],
   "source": [
    "# get unique states\n",
    "from scipy import stats as st\n",
    "\n",
    "states_unique = list(set(all_states_continuous))\n",
    "# for each state get average time spent in state\n",
    "all_states_list\n",
    "states_time = {}\n",
    "for i in range(len(all_states_list)):\n",
    "    # check if already in dict\n",
    "    if all_states_list[i] in states_time:\n",
    "        states_time[all_states_list[i]].append(all_times_list[i])\n",
    "    else:\n",
    "        states_time[all_states_list[i]] = [all_times_list[i]]\n",
    "# get average time spent in state\n",
    "states_time_avg = {}\n",
    "for s in states_time:\n",
    "    # get 90% confidence interval for states_time[s] which is a list of times\n",
    "    confidence_interval = st.t.interval(0.90, len(states_time[s])-1, loc=np.mean(states_time[s]), scale=st.sem(states_time[s]))\n",
    "    states_time_avg[s] = [np.mean(states_time[s]), np.median(states_time[s]), np.std(states_time[s]), confidence_interval]\n",
    "# sort states by average time spent in state\n",
    "# print\n",
    "for s in states_time_avg:\n",
    "    print(f' state {s} avg time {states_time_avg[s][0]:.2f} median time {states_time_avg[s][1]:.2f} std time {states_time_avg[s][2]:.2f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from hmmviz import TransGraph\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "T = pd.crosstab(\n",
    "    pd.Series(all_states_list[:-1], name='Today'),\n",
    "    pd.Series(all_states_list[1:], name='Tomorrow'),\n",
    "    normalize=0\n",
    ")\n",
    "'''\n",
    "T = pd.crosstab(\n",
    "    pd.Series(all_states_continuous[:-1], name='Today'),\n",
    "    pd.Series(all_states_continuous[1:], name='Tomorrow'),\n",
    "    normalize=0\n",
    ")\n",
    "'''\n",
    "graph = TransGraph(T)\n",
    "transition_matrix = np.array(graph.dataframe)\n",
    "nodes = list(graph.dataframe.index)\n",
    "# take each string in nodes and add new line if more than 2 words in string\n",
    "nodes_new = []\n",
    "for i in range(len(nodes)):\n",
    "    if len(nodes[i].split(' ')) > 2:\n",
    "        words = nodes[i].split(' ')\n",
    "        temp_str = ''\n",
    "        added_line = False\n",
    "        for j in range(len(words)-1):\n",
    "            temp_str += words[j] +' ' \n",
    "            if (j == 1 or len(temp_str)> 15) and not added_line:\n",
    "                temp_str += '\\n'\n",
    "                added_line = True\n",
    "        nodes_new.append(temp_str)\n",
    "    else:\n",
    "        nodes_new.append(nodes[i])\n",
    "nodes = nodes_new\n",
    "nodes[3] = 'Editing Written \\n Code'\n",
    "nodes[-2] = 'Writing \\n Documentation '\n",
    "labels_nodes = {}\n",
    "# color nodes\n",
    "frequencies = [11.31, 1.39, 11.9,4.28,7.45,0.01,11.56,10.91,22.4,4.2,0.53,14.05]\n",
    "avg_times = [29.24,  7.34, 24.22, 14.08, 106.51, 11.08, 10.67, 19.67, 10.58, 10.54,  9.12, 13.60]\n",
    "for i in range(len(nodes)):\n",
    "    #nodes[i] = nodes[i] + f' \\n {avg_times[i]:.2f}s , {frequencies[i]:.2f}per ' \n",
    "    labels_nodes[nodes[i]] = f\"{nodes[i]}\"#  \\n {avg_times[i]:.2f}s, {frequencies[i]:.2f}/100 \" \n",
    "# permute array nodes given new indices\n",
    "new_permutation = [0,4,1,8,7,5,9,11,3,2,10,6] # list(range(12))#\n",
    "nodes = [nodes[i] for i in new_permutation]\n",
    "# new permutation is the new order for nodes\n",
    "# make new transition matrix that is consistent with new permutation\n",
    "transition_matrix_new = np.zeros((len(nodes),len(nodes)))\n",
    "for i in range(len(nodes)):\n",
    "    for j in range(len(nodes)):\n",
    "        transition_matrix_new[i][j] = transition_matrix[new_permutation[i]][new_permutation[j]]\n",
    "transition_matrix = transition_matrix_new\n",
    "\n",
    "from collections import namedtuple\n",
    "\n",
    "cset = namedtuple('Mcset',\n",
    "            'rose indigo sand green cyan wine teal olive purple pale_grey black white yellow')\n",
    "colors = cset('#CC6677', '#332288', '#DDCC77', '#117733', '#88CCEE',\n",
    "            '#882255', '#44AA99', '#999933', '#AA4499', '#DDDDDD',\n",
    "            '#000000', '#FFFFFF', '#DDAA33')\n",
    "\n",
    "color_mapping = {'Debugging/Testing Code (H)': colors.yellow, 'Deferring Thought For Later (D)': colors.cyan, 'Editing Last Suggestion (X)': colors.rose, 'Editing Written Code(C)': colors.purple, 'Looking up Documentation (N)': colors.olive, 'Not Thinking': colors.white,  'Prompt Crafting (V)': colors.indigo, 'Thinking About New Code To Write (F)': colors.teal, 'Thinking/Verifying Suggestion (A)': colors.green, 'Waiting For Suggestion (G)': colors.pale_grey, 'Writing Documentation (B)': colors.sand, 'Writing New Functionality (Z)': colors.wine}\n",
    "nodes_colors = list(color_mapping.values())\n",
    "edgecolors  = {k: colors.black for k in color_mapping.keys()}\n",
    "nodes_colors = [nodes_colors[i] for i in new_permutation]\n",
    "\n",
    "\n",
    "color_mapping['Not Thinking (S)'] = '#FFFFFF'\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Not Thinking (S)', 'Writing Documentation (B)', 'Deferring Thought For Later (D)', 'Editing Written Code(C)', 'Waiting For Suggestion (G)', 'Looking up Documentation (N)', 'Prompt Crafting (V)', 'Editing Last Suggestion (X)', 'Debugging/Testing Code (H)', 'Thinking About New Code To Write (F)', 'Writing New Functionality (Z)', 'Thinking/Verifying Suggestion (A)']\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tkinter import W\n",
    "# sort statesfreq by frequency\n",
    "statesfreq = sorted(states_freq.items(), key=lambda x: x[1], reverse=False)\n",
    "# get keys sorted\n",
    "statesfreq_keys = [x[0] for x in statesfreq]\n",
    "print(statesfreq_keys)\n",
    "\n",
    "plt.figure(figsize=(10, 10))\n",
    "\n",
    "ax1 = plt.subplot(1,1,1)\n",
    "y = np.arange(12)*2\n",
    "w = 0.5\n",
    "plt.yticks(y  , statesfreq_keys, rotation='horizontal')\n",
    "error_bars = [(states_time_avg[s][3][1]-states_time_avg[s][3][0])/2 for s in statesfreq_keys]\n",
    "\n",
    "freq = ax1.barh(y , [states_freq[s] for s in statesfreq_keys],align='edge',  alpha=1,  height = 2*w, color=[color_mapping[s] for s in statesfreq_keys], edgecolor ='black')\n",
    "\n",
    "#time = ax1.barh(y , [states_time_avg[s][0] for s in statesfreq_keys], align='edge', xerr= error_bars,   height = w,  color=[color_mapping[s] for s in statesfreq_keys], edgecolor ='black', )\n",
    "#ax2 = ax1.twiny()\n",
    "ax1.set_xlabel('\\% of Session spent in State', fontsize=20)\n",
    "\n",
    "# change font size of x axis\n",
    "ax1.tick_params(axis='y', labelsize=20)\n",
    "ax1.tick_params(axis='x', labelsize=20)\n",
    "# make limit of x axis the same and 0\n",
    "ax1.set_xlim(0, 30)\n",
    "# more ticks for ax2\n",
    "ax1.set_xticks(np.arange(0, 30, 5))\n",
    "# axis titles\n",
    "# legend\n",
    "# show vertical lines\n",
    "\n",
    "ax1.axvline(x=5, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=10, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=15, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=20, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=25, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=30, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=35, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=40, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=45, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=50, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=55, color='black', linestyle='--', alpha=0.2)\n",
    "ax1.axvline(x=60, color='black', linestyle='--', alpha=0.2)\n",
    "\n",
    "#plt.legend([time, freq],['Average Time in State', 'Frequency'], fontsize=20)\n",
    "# save with tight   \n",
    "plt.savefig('histogram.pdf',dpi=1000,  bbox_inches='tight')   \n",
    "\n",
    "# show plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time In CUPS states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "all_states_continuous = []\n",
    "all_states_list = []\n",
    "all_times_list = []\n",
    "\n",
    "all_times_continuous = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'Edditing Last Suggestion (X)':\n",
    "            states[j] = 'Editing Last Suggestion (X)'\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = states[0]\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        if states[i] != last_state:\n",
    "            states_continuous.append(last_state)\n",
    "            last_state = states[i]\n",
    "            times_continuous.append(times_cumalitive)\n",
    "            times_cumalitive = times[i]\n",
    "        else:\n",
    "            times_cumalitive += times[i]\n",
    "    states_continuous.append(last_state)\n",
    "    times_continuous.append(times_cumalitive)\n",
    "    \n",
    "    all_states_list.extend(states)\n",
    "    all_times_list.extend(times)\n",
    "    all_states_continuous.extend(states_continuous)\n",
    "    all_times_continuous.extend(times_continuous)\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "states_unique = list(set(all_states_continuous))\n",
    "# for each session, count how many times each state is used\n",
    "\n",
    "states_count = [[0 for i in range(len(states_unique))] for _ in range(len(all_states))]\n",
    "for i in range(len(all_states)):\n",
    "    for j in range(len(all_states[i])):\n",
    "        states_count[i][states_unique.index(all_states[i][j])] += all_times[i][j]\n",
    "# normalize\n",
    "states_count = [[i/sum(states_count_single)*100 for i in states_count_single] for states_count_single in states_count]\n",
    "averaged_over_users = np.mean(states_count, axis=0)\n",
    "# median\n",
    "median = np.median(states_count, axis=0)\n",
    "# get std\n",
    "std = np.std(states_count, axis=0)\n",
    "# print\n",
    "print('Averaged Across Users \\n \\n')\n",
    "for i in range(len(states_unique)):\n",
    "    print(f' {states_unique[i]}  {averaged_over_users[i]:.2f} {std[i]:.2f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for each participant, see how often is verifying suggestion is the largest state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count for each list in states_count, how often the max is index 7\n",
    "count_top1 = 0\n",
    "count_top3 = 0\n",
    "for i in range(len(states_count)):\n",
    "    if np.argmax(states_count[i]) == 0:\n",
    "        count_top1 += 1\n",
    "        count_top3 += 1\n",
    "    # second argmax is 7\n",
    "    if np.argsort(states_count[i])[-2] == 0:\n",
    "        count_top3 += 1\n",
    "    # third argmax is 7\n",
    "    if np.argsort(states_count[i])[-3] == 0:\n",
    "        count_top3 += 1\n",
    "    #print(states_count[i][7])\n",
    "\n",
    "print(count_top1)\n",
    "print(count_top3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for each participant, see how often is writing code is the largest state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count for writiin\n",
    "count_top1 = 0\n",
    "count_top3 = 0\n",
    "for i in range(len(states_count)):\n",
    "    if np.argmax(states_count[i]) == 8:\n",
    "        count_top1 += 1\n",
    "        count_top3 += 1\n",
    "    # second argmax is 7\n",
    "    if np.argsort(states_count[i])[-2] == 8:\n",
    "        count_top3 += 1\n",
    "    # third argmax is 7\n",
    "    if np.argsort(states_count[i])[-3] == 8:\n",
    "        count_top3 += 1\n",
    "    print(states_count[i][8])\n",
    "print(count_top1)\n",
    "print(count_top3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count how often Copilot states spend their time in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# indices for copilot 0\n",
    "count_top1 = 0\n",
    "coderec_states_time = []\n",
    "for i in range(len(states_count)):\n",
    "    # sum indices at 1,2,3,5,7 of states_count[i]\n",
    "    sum_coderec_states = sum([states_count[i][0], states_count[i][3], states_count[i][4], states_count[i][10], states_count[i][11]])\n",
    "    print(sum_coderec_states)\n",
    "    coderec_states_time.append(sum_coderec_states)\n",
    "    if sum_coderec_states > 50:\n",
    "        count_top1 += 1\n",
    "\n",
    "print(f'how many more than 47percent {sum(i > 47 for i in coderec_states_time)/len(coderec_states_time)}')\n",
    "print(f'how many more than 21percent {sum(i > 21 for i in coderec_states_time)/len(coderec_states_time)}')\n",
    "\n",
    "print(\"COUNT TOP 1\") \n",
    "print(count_top1)\n",
    "print(np.mean(coderec_states_time))\n",
    "print(np.median(coderec_states_time))\n",
    "print(np.std(coderec_states_time))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 6.2: behavior by task and experience"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## By Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tasks_by_user = {'Algorithmic Problem' : [4,17,18], 'Data Manipulation': [1,2,11,20], 'Data Analysis':[5,8], 'Machine Learning':[3,7,12,15], 'Classes':[6,9], 'Writing Tests':[16],'Editing Code':[10,14,21], 'Logistic Regression':[13,19]}\n",
    "\n",
    "\n",
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'Edditing Last Suggestion (X)':\n",
    "            states[j] = 'Editing Last Suggestion (X)'\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n",
    "all_states_by_task = {}\n",
    "all_actions_by_task = {}\n",
    "all_times_by_task = {}\n",
    "for task in tasks_by_user:\n",
    "    all_states_by_task[task] = []\n",
    "    all_actions_by_task[task] = []\n",
    "    all_times_by_task[task] = []\n",
    "    for i in tasks_by_user[task]:\n",
    "        all_states_by_task[task].extend(all_states[i-1])\n",
    "        all_actions_by_task[task].extend(all_actions[i-1])\n",
    "        all_times_by_task[task].extend(all_times[i-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 0\n",
    "for task in tasks_by_user:\n",
    "    print(task)\n",
    "    z += 1\n",
    "    if z<= 3:\n",
    "        continue\n",
    "    import collections\n",
    "    counter = collections.Counter(all_actions_by_task[task])\n",
    "    # normalize counter\n",
    "    counter_normalized = {k: v/sum(counter.values()) for k, v in counter.items()}\n",
    "    print(counter)\n",
    "    print(f' Accept Rate is {counter[\"Accepted\"]/ counter[\"Shown\"]}')\n",
    "    all_actions_binary = [] \n",
    "    # for each list in all_actions, keep only Accepted and Rejected and convert to binary\n",
    "    # get standard error of bernoulli\n",
    "    # create list of 0s of lenght counter[\"Shown\"]\n",
    "    all_actions_binary = [0]*counter[\"Shown\"]\n",
    "    # add 1s for Accepted\n",
    "    all_actions_binary[:counter[\"Accepted\"]] = [1]*counter[\"Accepted\"]\n",
    "    print(f' Mean is {np.mean(all_actions_binary)}')\n",
    "    task_num_users = len(tasks_by_user[task])\n",
    "    print(f' Standard Error is {np.std(all_actions_binary)/np.sqrt(task_num_users)}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# chi square test to compare means\n",
    "# NOT USED ANYMORE\n",
    "from scipy.stats import chi2_contingency\n",
    "\n",
    "counter_dm = collections.Counter(all_actions_by_task['Data Manipulation'])\n",
    "counter_classes = collections.Counter(all_actions_by_task['Classes'])\n",
    "table = [[counter_dm['Shown'] -counter_dm['Accepted'], counter_dm['Accepted']],[counter_classes['Shown'] -counter_classes['Accepted'], counter_classes['Accepted']]]\n",
    "stat, p, dof, expected = chi2_contingency(table)\n",
    "print('stat=%.3f, p=%.3f' % (stat, p))\n",
    "# interpret p-value\n",
    "alpha = 0.05\n",
    "if p > alpha:\n",
    "    print('Same proportions of accepts (fail to reject H0)')\n",
    "else:\n",
    "    print('Different proportions of accepts (reject H0)')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "time_distrubution_by_task = {}\n",
    "for task in tasks_by_user:\n",
    "    print(f' \\n {task} \\n')\n",
    "\n",
    "    states_unique = list(set(all_states_continuous))\n",
    "# for each session, count how many times each state is used\n",
    "\n",
    "    states_count = [0 for i in range(len(states_unique))] \n",
    "    for i in range(len(all_states_by_task[task])):\n",
    "        states_count[states_unique.index(all_states_by_task[task][i])] += all_times_by_task[task][i]\n",
    "    # normalize\n",
    "    states_count = [i/sum(states_count)*100 for i in states_count] \n",
    "    time_distrubution_by_task[task] = states_count\n",
    "    # median\n",
    "    # get std\n",
    "    # print\n",
    "    # get indices of the top 3 states\n",
    "    top3_indices = np.argsort(states_count)[-3:]\n",
    "    print(f' {states_unique[top3_indices[2]]} ({states_count[top3_indices[2]]:.2f}) newline  {states_unique[top3_indices[1]]} ({states_count[top3_indices[1]]:.2f}) newline  {states_unique[top3_indices[0]]} ({states_count[top3_indices[0]]:.2f})')\n",
    "    #for i in range(len(states_unique)):\n",
    "    #    print(f' {states_unique[i]}  {states_count[i]:.2f} ')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## By Expertise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "logs_by_user_session_labeled[3].UserExperience[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(logs_by_user_session_labeled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'Edditing Last Suggestion (X)':\n",
    "            states[j] = 'Editing Last Suggestion (X)'\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n",
    "\n",
    "all_states_by_expertise = {'copilot_exp': [], 'no_copilot_exp': [], 'exp_prog': [], 'no_exp_prog': []}\n",
    "all_actions_by_expertise= {'copilot_exp': [], 'no_copilot_exp': [], 'exp_prog': [], 'no_exp_prog': []}\n",
    "all_times_by_expertise = {'copilot_exp': [], 'no_copilot_exp': [], 'exp_prog': [], 'no_exp_prog': []}\n",
    "group_count = {'copilot_exp': 0, 'no_copilot_exp': 0, 'exp_prog': 0, 'no_exp_prog': 0}\n",
    "\n",
    "for i in range(len(all_states)):\n",
    "    user_charac= logs_by_user_session_labeled[i].UserExperience[0]\n",
    "    if user_charac['How often do you use Copilot outside of today’s session?'] != 'Never':\n",
    "        all_states_by_expertise['copilot_exp'].extend(all_states[i])\n",
    "        all_actions_by_expertise['copilot_exp'].extend(all_actions[i])\n",
    "        all_times_by_expertise['copilot_exp'].extend(all_times[i])\n",
    "        group_count['copilot_exp'] += 1\n",
    "    else:\n",
    "        all_states_by_expertise['no_copilot_exp'].extend(all_states[i])\n",
    "        all_actions_by_expertise['no_copilot_exp'].extend(all_actions[i])\n",
    "        all_times_by_expertise['no_copilot_exp'].extend(all_times[i])\n",
    "        group_count['no_copilot_exp'] += 1\n",
    "    if user_charac['Which best describes your programming experience?'] in [' 3 to 5 years professional programming experience', ' 0 to 2 years professional programming experience']:\n",
    "        all_states_by_expertise['no_exp_prog'].extend(all_states[i])\n",
    "        all_actions_by_expertise['no_exp_prog'].extend(all_actions[i])\n",
    "        all_times_by_expertise['no_exp_prog'].extend(all_times[i])\n",
    "        group_count['no_exp_prog'] += 1\n",
    "    else:\n",
    "        all_states_by_expertise['exp_prog'].extend(all_states[i])\n",
    "        all_actions_by_expertise['exp_prog'].extend(all_actions[i])\n",
    "        all_times_by_expertise['exp_prog'].extend(all_times[i])\n",
    "        group_count['exp_prog'] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for group in all_states_by_expertise:\n",
    "    print(group)\n",
    "    \n",
    "    import collections\n",
    "    counter = collections.Counter(all_actions_by_expertise[group])\n",
    "    # normalize counter\n",
    "    counter_normalized = {k: v/sum(counter.values()) for k, v in counter.items()}\n",
    "    print(counter)\n",
    "    print(f' Accept Rate is {counter[\"Accepted\"]/ counter[\"Shown\"]}')\n",
    "    all_actions_binary = [] \n",
    "    # for each list in all_actions, keep only Accepted and Rejected and convert to binary\n",
    "    # get standard error of bernoulli\n",
    "    # create list of 0s of lenght counter[\"Shown\"]\n",
    "    all_actions_binary = [0]*counter[\"Shown\"]\n",
    "    # add 1s for Accepted\n",
    "    all_actions_binary[:counter[\"Accepted\"]] = [1]*counter[\"Accepted\"]\n",
    "    print(f' Mean is {np.mean(all_actions_binary)}')\n",
    "    group_size = group_count[group]\n",
    "    print(f' Standard Error is {np.std(all_actions_binary)/np.sqrt(group_size)}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# chi square test to compare means\n",
    "# NOT USED\n",
    "from scipy.stats import chi2_contingency\n",
    "\n",
    "counter_exp = collections.Counter(all_actions_by_expertise['copilot_exp'])\n",
    "counter_notexp = collections.Counter(all_actions_by_expertise['no_copilot_exp'])\n",
    "table = [[counter_exp['Shown'] -counter_exp['Accepted'], counter_exp['Accepted']],[counter_notexp['Shown'] -counter_notexp['Accepted'], counter_notexp['Accepted']]]\n",
    "stat, p, dof, expected = chi2_contingency(table)\n",
    "print('stat=%.3f, p=%.3f' % (stat, p))\n",
    "# interpret p-value\n",
    "alpha = 0.05\n",
    "if p > alpha:\n",
    "    print('Same proportions of accepts (fail to reject H0)')\n",
    "else:\n",
    "    print('Different proportions of accepts (reject H0)')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# chi square test to compare means\n",
    "# NOT USED\n",
    "from scipy.stats import chi2_contingency\n",
    "\n",
    "counter_exp = collections.Counter(all_actions_by_expertise['exp_prog'])\n",
    "counter_notexp = collections.Counter(all_actions_by_expertise['no_exp_prog'])\n",
    "table = [[counter_exp['Shown'] -counter_exp['Accepted'], counter_exp['Accepted']],[counter_notexp['Shown'] -counter_notexp['Accepted'], counter_notexp['Accepted']]]\n",
    "stat, p, dof, expected = chi2_contingency(table)\n",
    "print('stat=%.3f, p=%.3f' % (stat, p))\n",
    "# interpret p-value\n",
    "alpha = 0.05\n",
    "if p > alpha:\n",
    "    print('Same proportions of accepts (fail to reject H0)')\n",
    "else:\n",
    "    print('Different proportions of accepts (reject H0)')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Section 6.3 Defer Thought\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "all_suggestions = []\n",
    "all_states_continuous = []\n",
    "all_times_continuous = []\n",
    "all_actions_continuous = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    suggestions = logs_by_user_session_labeled[i].CurrentSuggestion.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    actions_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = \"\"\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        if states[i] != last_state:\n",
    "            states_continuous.append(states[i])\n",
    "            last_state = states[i]\n",
    "            times_continuous.append(times_cumalitive + times[i])\n",
    "            times_cumalitive = 0\n",
    "        else:\n",
    "            times_cumalitive += times[i]\n",
    "    all_states_continuous.extend(states_continuous)\n",
    "    all_times_continuous.extend(times_continuous)\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n",
    "    all_suggestions.append(suggestions)\n",
    "# merge all pandas dataframes of logs_by_user_session_labeled into a single dataframe\n",
    "all_users_df = pd.concat(logs_by_user_session_labeled)\n",
    "all_users_df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter_all = collections.Counter(all_states_continuous)\n",
    "print(counter_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get suggestions in all_users_df where LabeledState is Defered Thought\n",
    "defered_thought_suggestions = all_users_df[all_users_df['LabeledState'] == 'Deferring Thought For Later (D)'].CurrentSuggestion.to_numpy()\n",
    "thinking_suggestions = all_users_df[all_users_df['LabeledState'] == 'Thinking/Verifying Suggestion (A)'].CurrentSuggestion.to_numpy()\n",
    "# print random sample of suggestions from each \n",
    "#print('defered_thought_suggestions \\n \\n')\n",
    "#print(defered_thought_suggestions[np.random.randint(len(defered_thought_suggestions), size=10)])\n",
    "#print('thinking suggestions \\n \\n')\n",
    "#print(thinking_suggestions[np.random.randint(len(thinking_suggestions), size=10)])\n",
    "\n",
    "# compare number of characters and lines between the two groups\n",
    "defered_thought_suggestions_characters = []\n",
    "thinking_suggestions_characters = []\n",
    "defered_thought_suggestions_lines = []\n",
    "thinking_suggestions_lines = []\n",
    "for i in range(len(defered_thought_suggestions)):\n",
    "    defered_thought_suggestions_characters.append(len(defered_thought_suggestions[i]))\n",
    "    defered_thought_suggestions_lines.append(len(defered_thought_suggestions[i].split('\\\\n')))\n",
    "\n",
    "for i in range(len(thinking_suggestions)):\n",
    "    thinking_suggestions_characters.append(len(thinking_suggestions[i]))\n",
    "    thinking_suggestions_lines.append(len(thinking_suggestions[i].split('\\\\n')))\n",
    "\n",
    "# print average and median number of characters and lines for each group\n",
    "print(f'n = {len(defered_thought_suggestions)} Avg characters for defered thought suggestions: {np.mean(defered_thought_suggestions_characters):.2f} median characters: {np.median(defered_thought_suggestions_characters):.2f} std characters: {np.std(defered_thought_suggestions_characters):.2f}')\n",
    "print(f'Avg lines for defered thought suggestions: {np.mean(defered_thought_suggestions_lines):.2f} median lines: {np.median(defered_thought_suggestions_lines):.2f} std lines: {np.std(defered_thought_suggestions_lines):.2f}')\n",
    "print(f'n = {len(thinking_suggestions_characters)} Avg characters for thinking suggestions: {np.mean(thinking_suggestions_characters):.2f} median characters: {np.median(thinking_suggestions_characters):.2f} std characters: {np.std(thinking_suggestions_characters):.2f}')\n",
    "print(f'Avg lines for thinking suggestions: {np.mean(thinking_suggestions_lines):.2f} median lines: {np.median(thinking_suggestions_lines):.2f} std lines: {np.std(thinking_suggestions_lines):.2f}')\n",
    "# two sample t test, one for characters and one for lines\n",
    "from scipy.stats import ttest_ind\n",
    "print(f'ttest_ind(thinking_suggestions_characters, defered_thought_suggestions_characters) = {ttest_ind(thinking_suggestions_characters, defered_thought_suggestions_characters)}')\n",
    "print(f'ttest_ind(thinking_suggestions_lines, defered_thought_suggestions_lines) = {ttest_ind(thinking_suggestions_lines, defered_thought_suggestions_lines)}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prev_states_defer = {}\n",
    "prev_states_thinking = {}\n",
    "for j in range(1, len(all_states)):\n",
    "    for i in range(len(all_states[j])):\n",
    "        if all_states[j][i] == 'Deferring Thought For Later (D)':\n",
    "            if all_states[j][i-1] not in prev_states_defer:\n",
    "                prev_states_defer[all_states[j][i-1]] = 1\n",
    "            else:\n",
    "                prev_states_defer[all_states[j][i-1]] += 1\n",
    "        if all_states[j][i] == 'Thinking/Verifying Suggestion (A)':\n",
    "            if all_states[j][i-1] not in prev_states_thinking:\n",
    "                prev_states_thinking[all_states[j][i-1]] = 1\n",
    "            else:\n",
    "                prev_states_thinking[all_states[j][i-1]] += 1\n",
    "\n",
    "# instead of counts make it a probability\n",
    "sum_defer = sum(prev_states_defer.values())\n",
    "for key in prev_states_defer:\n",
    "    prev_states_defer[key] = prev_states_defer[key]/sum_defer\n",
    "sum_thinking = sum(prev_states_thinking.values())\n",
    "for key in prev_states_thinking:\n",
    "    prev_states_thinking[key] = prev_states_thinking[key]/sum_thinking\n",
    "    \n",
    "# print\n",
    "print(f'prev_states_defer = {prev_states_defer}')\n",
    "print(f'prev_states_thinking = {prev_states_thinking}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts_edits = {'Deferring Thought For Later (D)':0, 'Thinking/Verifying Suggestion (A)':0, 'Waiting For Suggestion (G)':0, 'Thinking About New Code To Write (F)':0}\n",
    "counts_states = {'Deferring Thought For Later (D)':0, 'Thinking/Verifying Suggestion (A)':0, 'Waiting For Suggestion (G)':0, 'Thinking About New Code To Write (F)':0}\n",
    "\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(len(all_states[j])-1):\n",
    "        if all_actions[j][i] in ['Accepted']:\n",
    "            if all_states[j][i] == 'Thinking/Verifying Suggestion (A)':\n",
    "                counts_states['Thinking/Verifying Suggestion (A)'] += 1\n",
    "                if all_states[j][i+1] == 'Editing Last Suggestion (X)':\n",
    "                    counts_edits['Thinking/Verifying Suggestion (A)'] += 1\n",
    "            if all_states[j][i] == 'Deferring Thought For Later (D)':\n",
    "                counts_states['Deferring Thought For Later (D)'] += 1\n",
    "                if all_states[j][i+1] == 'Thinking/Verifying Suggestion (A)':\n",
    "                    counts_edits['Deferring Thought For Later (D)'] += 1\n",
    "            if all_states[j][i] == 'Waiting For Suggestion (G)':\n",
    "                counts_states['Waiting For Suggestion (G)'] += 1\n",
    "                if all_states[j][i+1] == 'Thinking/Verifying Suggestion (A)':\n",
    "                    counts_edits['Waiting For Suggestion (G)'] += 1\n",
    "            if all_states[j][i] == 'Thinking About New Code To Write (F)':\n",
    "                counts_states['Thinking About New Code To Write (F)'] += 1\n",
    "                if all_states[j][i+1] == 'Thinking/Verifying Suggestion (A)':\n",
    "                    counts_edits['Thinking About New Code To Write (F)'] += 1\n",
    "# print probability of edit\n",
    "print(counts_edits)\n",
    "print(counts_states)\n",
    "print(f'Probability of edit Thinking/Verifying Suggestion (A):  {counts_edits[\"Thinking/Verifying Suggestion (A)\"]/counts_states[\"Thinking/Verifying Suggestion (A)\"]}')\n",
    "print(f'Probability of edit Deferring Thought For Late: {counts_edits[\"Deferring Thought For Later (D)\"]/counts_states[\"Deferring Thought For Later (D)\"]}')\n",
    "print(f'Probability of edit Thinking About New Code To Write: {counts_edits[\"Thinking About New Code To Write (F)\"]/counts_states[\"Thinking About New Code To Write (F)\"]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "thinking_accepts = [0] * counts_states['Thinking/Verifying Suggestion (A)']\n",
    "thinking_accepts[0:counts_edits['Thinking/Verifying Suggestion (A)']] = [1] * counts_edits['Thinking/Verifying Suggestion (A)']\n",
    "writing_accepts = [0] * counts_states['Deferring Thought For Later (D)']\n",
    "writing_accepts[0:counts_edits['Deferring Thought For Later (D)']] = [1] * counts_edits['Deferring Thought For Later (D)']\n",
    "# shuffle both arrays\n",
    "np.random.shuffle(thinking_accepts)\n",
    "np.random.shuffle(writing_accepts)\n",
    "\n",
    "\n",
    "# chi square test to compare means\n",
    "from scipy.stats import chi2_contingency\n",
    "table = [[counts_edits['Thinking/Verifying Suggestion (A)'], counts_states['Thinking/Verifying Suggestion (A)'] - counts_edits['Thinking/Verifying Suggestion (A)']], [counts_edits['Deferring Thought For Later (D)'], counts_states['Deferring Thought For Later (D)'] - counts_edits['Deferring Thought For Later (D)']]]\n",
    "\n",
    "stat, p, dof, expected = chi2_contingency(table)\n",
    "print('stat=%.3f, p=%.3f' % (stat, p))\n",
    "# interpret p-value\n",
    "alpha = 0.05\n",
    "if p > alpha:\n",
    "    print('Same proportions of accepts (fail to reject H0)')\n",
    "else:\n",
    "    print('Different proportions of accepts (reject H0)')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# accept rate before shown\n",
    "states_accept = {}\n",
    "states_count = {}\n",
    "\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(1, len(all_states[j])):\n",
    "        if all_actions[j][i] in ['Accepted', 'Rejected']:\n",
    "            state_now = all_states[j][i]\n",
    "            state_before = all_states[j][i-1]\n",
    "            if state_before not in states_count:\n",
    "                states_accept[state_before] = 0\n",
    "                states_count[state_before] = 1\n",
    "            else:  \n",
    "                states_count[state_before] += 1\n",
    "            \n",
    "            if all_actions[j][i] == 'Accepted':\n",
    "                states_accept[state_before] += 1\n",
    "\n",
    "\n",
    "print(f'Probability of accept for each state:')\n",
    "for state in states_count:\n",
    "    print(f'{state}: {states_accept[state]/states_count[state]} {np.std([1]*states_accept[state] + [0]*(states_count[state] - states_accept[state]))/np.sqrt(states_count[state])}')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# accept rate while shown\n",
    "states_accept = {}\n",
    "states_count = {}\n",
    "\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(1, len(all_states[j])):\n",
    "        if all_actions[j][i] in ['Accepted', 'Rejected']:\n",
    "            state_now = all_states[j][i]\n",
    "            if state_now not in states_count:\n",
    "                states_count[state_now] = 1\n",
    "                states_accept[state_now] = 0\n",
    "\n",
    "            else:\n",
    "                states_count[state_now] += 1\n",
    "            \n",
    "            if all_actions[j][i] == 'Accepted':\n",
    "                states_accept[state_now] += 1\n",
    "\n",
    "print(f'Probability of accept for each state:')\n",
    "# and standard error\n",
    "for state in states_count:\n",
    "    print(f'{state}: {states_accept[state]/states_count[state]} {np.std([1]*states_accept[state] + [0]*(states_count[state] - states_accept[state]))/np.sqrt(states_count[state])}')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "thinking_accepts = [0] * states_count['Thinking/Verifying Suggestion (A)']\n",
    "thinking_accepts[0:states_accept['Thinking/Verifying Suggestion (A)']] = [1] * states_accept['Thinking/Verifying Suggestion (A)']\n",
    "writing_accepts = [0] * states_count['Thinking About New Code To Write (F)']\n",
    "writing_accepts[0:states_accept['Thinking About New Code To Write (F)']] = [1] * states_accept['Thinking About New Code To Write (F)']\n",
    "# shuffle both arrays\n",
    "np.random.shuffle(thinking_accepts)\n",
    "np.random.shuffle(writing_accepts)\n",
    "\n",
    "\n",
    "# chi square test to compare means\n",
    "from scipy.stats import chi2_contingency\n",
    "table = [[states_accept['Thinking/Verifying Suggestion (A)'], states_count['Thinking/Verifying Suggestion (A)'] - states_accept['Thinking/Verifying Suggestion (A)']], [states_accept['Thinking About New Code To Write (F)'], states_count['Thinking About New Code To Write (F)'] - states_accept['Thinking About New Code To Write (F)']]]\n",
    "stat, p, dof, expected = chi2_contingency(table)\n",
    "print('stat=%.3f, p=%.3f' % (stat, p))\n",
    "# interpret p-value\n",
    "alpha = 0.05\n",
    "if p > alpha:\n",
    "    print('Same proportions of accepts (fail to reject H0)')\n",
    "else:\n",
    "    print('Different proportions of accepts (reject H0)')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cups time to verify (section 6.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "all_suggestions = []\n",
    "all_states_continuous = []\n",
    "all_times_continuous = []\n",
    "all_actions_continuous = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    suggestions = logs_by_user_session_labeled[i].CurrentSuggestion.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    actions_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = \"\"\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        if states[i] != last_state:\n",
    "            states_continuous.append(states[i])\n",
    "            last_state = states[i]\n",
    "            times_continuous.append(times_cumalitive + times[i])\n",
    "            times_cumalitive = 0\n",
    "        else:\n",
    "            times_cumalitive += times[i]\n",
    "    all_states_continuous.extend(states_continuous)\n",
    "    all_times_continuous.extend(times_continuous)\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n",
    "    all_suggestions.append(suggestions)\n",
    "# merge all pandas dataframes of logs_by_user_session_labeled into a single dataframe\n",
    "all_users_df = pd.concat(logs_by_user_session_labeled)\n",
    "all_users_df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for defer thought, check time after\n",
    "defer_thought_original = []\n",
    "defer_thought_new = []\n",
    "post_thinking_time = []\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(len(all_states[j])-1):\n",
    "        if  all_states[j][i] == 'Deferring Thought For Later (D)' and all_actions[j][i] == 'Accepted':\n",
    "            defer_thought_original.append(all_times[j][i])\n",
    "            if all_states[j][i+1] == 'Thinking/Verifying Suggestion (A)':\n",
    "                defer_thought_new.append(all_times[j][i+1]+ all_times[j][i])\n",
    "                post_thinking_time.append(all_times[j][i+1])\n",
    "            else:\n",
    "                defer_thought_new.append(all_times[j][i])\n",
    "# mean of original and new\n",
    "print(f'how often verify after defer = {len(post_thinking_time)/len(defer_thought_new)}')\n",
    "print(f'Defer Thought should add the thinking veriyfing suggestion time after the action n = {len(defer_thought_original)}')\n",
    "print(f' (means) before adjusting: {np.mean(defer_thought_original):.2f} +- {np.std(defer_thought_original):.2f} after adjusting: {np.mean(defer_thought_new):.2f} +- {np.std(defer_thought_new):.2f}')\n",
    "print(f' (median) before adjusting: {np.median(defer_thought_original):.2f} +- {np.std(defer_thought_original):.2f} after adjusting: {np.median(defer_thought_new):.2f} +- {np.std(defer_thought_new):.2f}')\n",
    "# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_rel.html\n",
    "print(f' post thinking time (means) {np.mean(post_thinking_time):.2f} +- {np.std(post_thinking_time):.2f} occurs {len(post_thinking_time)/len(defer_thought_new)}')\n",
    "# paired t-test\n",
    "import scipy\n",
    "def paired_ttest(a, b):\n",
    "    return scipy.stats.ttest_rel(a, b)\n",
    "print(paired_ttest(defer_thought_original, defer_thought_new))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for thinking , check time after\n",
    "thinking_original = []\n",
    "thinking_new = []\n",
    "post_thinking_time = []\n",
    "\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(len(all_states[j])-1):\n",
    "        if  all_states[j][i] == 'Thinking/Verifying Suggestion (A)' and all_actions[j][i] == 'Accepted':\n",
    "            thinking_original.append(all_times[j][i])\n",
    "            new_time = all_times[j][i]\n",
    "            if all_states[j][i+1] == 'Thinking/Verifying Suggestion (A)':\n",
    "                new_time += all_times[j][i+1]\n",
    "                post_thinking_time.append(all_times[j][i+1])\n",
    "\n",
    "            #if all_states[j][i-1] == 'Waiting For Suggestion (G)':\n",
    "            #    new_time += all_times[j][i-1]\n",
    "            thinking_new.append(new_time)\n",
    "# mean of original and new\n",
    "\n",
    "# print\n",
    "print(f' post thinking time (means) {np.mean(post_thinking_time):.2f} +- {np.std(post_thinking_time):.2f} occurs {len(post_thinking_time)/len(thinking_new)}')\n",
    "\n",
    "print(f'Thinking should add  and time spent thinking after   n={len(thinking_new)} ')\n",
    "print(f'(means) before adjusting: {np.mean(thinking_original):.2f} +- {np.std(thinking_original):.2f} after adjusting: {np.mean(thinking_new):.2f} +- {np.std(thinking_new):.2f}')\n",
    "print(f' (median) before adjusting: {np.median(thinking_original):.2f} +- {np.std(thinking_original):.2f} after adjusting: {np.median(thinking_new):.2f} +- {np.std(thinking_new):.2f}')\n",
    "print(paired_ttest(thinking_original, thinking_new))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "thinking_original = []\n",
    "thinking_new = []\n",
    "waiting_time = []\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(len(all_states[j])-1):\n",
    "        if all_actions[j][i] in ['Accepted', 'Rejected'] and all_states[j][i] in ['Thinking/Verifying Suggestion (A)',\n",
    "                'Waiting For Suggestion (G)', 'Deferring Thought For Later (D)', 'Thinking About New Code To Write (F)']:\n",
    "            thinking_original.append(all_times[j][i])\n",
    "            new_time = all_times[j][i]\n",
    "            if all_states[j][i-1] == 'Waiting For Suggestion (G)':\n",
    "                waiting_time.append(all_times[j][i-1])\n",
    "                new_time += all_times[j][i-1]\n",
    "            thinking_new.append(new_time)\n",
    "# mean of original and new\n",
    "\n",
    "# print\n",
    "print(f'Thinking should add  the time spent waiting before  n={len(thinking_new)} ')\n",
    "print(f'(means) before adjusting: {np.mean(thinking_original):.2f} +- {np.std(thinking_original):.2f} after adjusting: {np.mean(thinking_new):.2f} +- {np.std(thinking_new):.2f}')\n",
    "print(f' (median) before adjusting: {np.median(thinking_original):.2f} +- {np.std(thinking_original):.2f} after adjusting: {np.median(thinking_new):.2f} +- {np.std(thinking_new):.2f}')\n",
    "print(paired_ttest(thinking_original, thinking_new))\n",
    "print(f' waiting time {np.mean(waiting_time):.2f} +- {np.std(waiting_time):.2f} and probability {len(waiting_time)/len(thinking_new)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prompt Crafting Insights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "all_suggestions = []\n",
    "all_states_continuous = []\n",
    "all_times_continuous = []\n",
    "all_actions_continuous = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    suggestions = logs_by_user_session_labeled[i].CurrentSuggestion.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    actions_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = \"\"\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        if states[i] != last_state:\n",
    "            states_continuous.append(states[i])\n",
    "            last_state = states[i]\n",
    "            times_continuous.append(times_cumalitive + times[i])\n",
    "            times_cumalitive = 0\n",
    "        else:\n",
    "            times_cumalitive += times[i]\n",
    "    all_states_continuous.extend(states_continuous)\n",
    "    all_times_continuous.extend(times_continuous)\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n",
    "    all_suggestions.append(suggestions)\n",
    "# merge all pandas dataframes of logs_by_user_session_labeled into a single dataframe\n",
    "all_users_df = pd.concat(logs_by_user_session_labeled)\n",
    "all_users_df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# probability of accept while prompt crafting\n",
    "prompt_crafting_count = 0\n",
    "accepted_when_prompt_crafting = 0\n",
    "for j in range(len(all_states)):\n",
    "    for i in range(1, len(all_states[j])-1):\n",
    "        if all_actions[j][i] in ['Accepted', 'Rejected']:\n",
    "            if all_states[j][i] == 'Prompt Crafting (V)':\n",
    "                prompt_crafting_count += 1\n",
    "                if all_actions[j][i] == 'Accepted':# and all_states[j][i+1] == 'Prompt Crafting (V)':\n",
    "                        accepted_when_prompt_crafting += 1\n",
    "\n",
    "print(f'n = {prompt_crafting_count} Probability of accept while prompt crafting: {accepted_when_prompt_crafting/prompt_crafting_count}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# start prompt crafting - inside should be anything but \n",
    "prompt_crafting_count = 0\n",
    "accepted_when_prompt_crafting = 0\n",
    "for j in range(len(all_states)):\n",
    "    i = 0\n",
    "    while i < len(all_states[j]):\n",
    "        if all_states[j][i] == 'Prompt Crafting (V)':\n",
    "            # get state where prompt crafting ends\n",
    "            prompt_crafting_count += 1\n",
    "            last_episode_state = i\n",
    "            first_pos_accept = -1\n",
    "            for k in range(i, len(all_states[j]) ):\n",
    "                if all_actions[j][k] == 'Accepted':\n",
    "                    first_pos_accept = k\n",
    "                    break\n",
    "\n",
    "            for k in range(i, len(all_states[j])):\n",
    "                if all_states[j][k] in ['Writing New Functionality (Z)', 'Editing Written Code(C)','Thinking About New Code To Write (F)','Debugging/Testing Code (H)', 'Looking up Documentation (N)', 'Writing Documentation (B)']:\n",
    "                    # this means prompt crafting ended, let's check if there was an accept just before prompt crafting ended\n",
    "                    last_episode_state = k\n",
    "                    break\n",
    "\n",
    "            last_prompt_state = i\n",
    "            while all_states[j][last_prompt_state] == 'Prompt Crafting (V)' and last_prompt_state < len(all_states[j]) -1:\n",
    "                last_prompt_state += 1\n",
    "            last_prompt_state -= 1\n",
    "\n",
    "            if first_pos_accept < max(last_prompt_state,last_episode_state):\n",
    "                accepted_when_prompt_crafting += 1\n",
    "                \n",
    "            i = max(last_episode_state,last_prompt_state) +1\n",
    "            # print the trajectory\n",
    "        else:\n",
    "            i += 1\n",
    "\n",
    "print(f'n = {prompt_crafting_count} Probability of accept after prompt crafting: {accepted_when_prompt_crafting/prompt_crafting_count}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transitions between states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from entropy_utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states = []\n",
    "all_actions = []\n",
    "all_times = []\n",
    "all_states_continuous = []\n",
    "all_states_list = []\n",
    "all_times_list = []\n",
    "\n",
    "all_times_continuous = []\n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'Edditing Last Suggestion (X)':\n",
    "            states[j] = 'Editing Last Suggestion (X)'\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = states[0]\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        if states[i] != last_state:\n",
    "            states_continuous.append(last_state)\n",
    "            last_state = states[i]\n",
    "            times_continuous.append(times_cumalitive)\n",
    "            times_cumalitive = times[i]\n",
    "        else:\n",
    "            times_cumalitive += times[i]\n",
    "    states_continuous.append(last_state)\n",
    "    times_continuous.append(times_cumalitive)\n",
    "    \n",
    "    all_states_list.extend(states)\n",
    "    all_times_list.extend(times)\n",
    "    all_states_continuous.extend(states_continuous)\n",
    "    all_times_continuous.extend(times_continuous)\n",
    "    all_states.append(states)\n",
    "    all_actions.append(actions)\n",
    "    all_times.append(times)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = pd.crosstab(\n",
    "    pd.Series(all_states_continuous[:-1], name='Today'),\n",
    "    pd.Series(all_states_continuous[1:], name='Tomorrow'),\n",
    "    normalize=0\n",
    ")\n",
    "\n",
    "\n",
    "graph = TransGraph(T)\n",
    "nodes_original = list(graph.dataframe.index)\n",
    "transition_matrix = np.array(graph.dataframe)\n",
    "nodes = list(graph.dataframe.index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability from Debugging/Testing Code (H) to Debugging/Testing Code (H): 0.0\n",
      "Probability from Debugging/Testing Code (H) to Deferring Thought For Later (D): 0.05714285714285714\n",
      "Probability from Debugging/Testing Code (H) to Editing Last Suggestion (X): 0.0\n",
      "Probability from Debugging/Testing Code (H) to Editing Written Code(C): 0.17142857142857143\n",
      "Probability from Debugging/Testing Code (H) to Looking up Documentation (N): 0.0\n",
      "Probability from Debugging/Testing Code (H) to Not Thinking (S): 0.0\n",
      "Probability from Debugging/Testing Code (H) to Prompt Crafting (V): 0.17142857142857143\n",
      "Probability from Debugging/Testing Code (H) to Thinking About New Code To Write (F): 0.05714285714285714\n",
      "Probability from Debugging/Testing Code (H) to Thinking/Verifying Suggestion (A): 0.3142857142857143\n",
      "Probability from Debugging/Testing Code (H) to Waiting For Suggestion (G): 0.0\n",
      "Probability from Debugging/Testing Code (H) to Writing Documentation (B): 0.0\n",
      "Probability from Debugging/Testing Code (H) to Writing New Functionality (Z): 0.22857142857142856\n",
      "Probability from Deferring Thought For Later (D) to Debugging/Testing Code (H): 0.04918032786885246\n",
      "Probability from Deferring Thought For Later (D) to Deferring Thought For Later (D): 0.0\n",
      "Probability from Deferring Thought For Later (D) to Editing Last Suggestion (X): 0.13114754098360656\n",
      "Probability from Deferring Thought For Later (D) to Editing Written Code(C): 0.0\n",
      "Probability from Deferring Thought For Later (D) to Looking up Documentation (N): 0.04918032786885246\n",
      "Probability from Deferring Thought For Later (D) to Not Thinking (S): 0.0\n",
      "Probability from Deferring Thought For Later (D) to Prompt Crafting (V): 0.0\n",
      "Probability from Deferring Thought For Later (D) to Thinking About New Code To Write (F): 0.06557377049180328\n",
      "Probability from Deferring Thought For Later (D) to Thinking/Verifying Suggestion (A): 0.5409836065573771\n",
      "Probability from Deferring Thought For Later (D) to Waiting For Suggestion (G): 0.13114754098360656\n",
      "Probability from Deferring Thought For Later (D) to Writing Documentation (B): 0.0\n",
      "Probability from Deferring Thought For Later (D) to Writing New Functionality (Z): 0.03278688524590164\n",
      "Probability from Editing Last Suggestion (X) to Debugging/Testing Code (H): 0.013513513513513514\n",
      "Probability from Editing Last Suggestion (X) to Deferring Thought For Later (D): 0.05405405405405406\n",
      "Probability from Editing Last Suggestion (X) to Editing Last Suggestion (X): 0.0\n",
      "Probability from Editing Last Suggestion (X) to Editing Written Code(C): 0.02702702702702703\n",
      "Probability from Editing Last Suggestion (X) to Looking up Documentation (N): 0.0\n",
      "Probability from Editing Last Suggestion (X) to Not Thinking (S): 0.0\n",
      "Probability from Editing Last Suggestion (X) to Prompt Crafting (V): 0.13513513513513514\n",
      "Probability from Editing Last Suggestion (X) to Thinking About New Code To Write (F): 0.25675675675675674\n",
      "Probability from Editing Last Suggestion (X) to Thinking/Verifying Suggestion (A): 0.25675675675675674\n",
      "Probability from Editing Last Suggestion (X) to Waiting For Suggestion (G): 0.0\n",
      "Probability from Editing Last Suggestion (X) to Writing Documentation (B): 0.02702702702702703\n",
      "Probability from Editing Last Suggestion (X) to Writing New Functionality (Z): 0.22972972972972974\n",
      "Probability from Editing Written Code(C) to Debugging/Testing Code (H): 0.07894736842105263\n",
      "Probability from Editing Written Code(C) to Deferring Thought For Later (D): 0.02631578947368421\n",
      "Probability from Editing Written Code(C) to Editing Last Suggestion (X): 0.07894736842105263\n",
      "Probability from Editing Written Code(C) to Editing Written Code(C): 0.0\n",
      "Probability from Editing Written Code(C) to Looking up Documentation (N): 0.02631578947368421\n",
      "Probability from Editing Written Code(C) to Not Thinking (S): 0.0\n",
      "Probability from Editing Written Code(C) to Prompt Crafting (V): 0.10526315789473684\n",
      "Probability from Editing Written Code(C) to Thinking About New Code To Write (F): 0.15789473684210525\n",
      "Probability from Editing Written Code(C) to Thinking/Verifying Suggestion (A): 0.18421052631578946\n",
      "Probability from Editing Written Code(C) to Waiting For Suggestion (G): 0.02631578947368421\n",
      "Probability from Editing Written Code(C) to Writing Documentation (B): 0.02631578947368421\n",
      "Probability from Editing Written Code(C) to Writing New Functionality (Z): 0.2894736842105263\n",
      "Probability from Looking up Documentation (N) to Debugging/Testing Code (H): 0.0\n",
      "Probability from Looking up Documentation (N) to Deferring Thought For Later (D): 0.1\n",
      "Probability from Looking up Documentation (N) to Editing Last Suggestion (X): 0.0\n",
      "Probability from Looking up Documentation (N) to Editing Written Code(C): 0.1\n",
      "Probability from Looking up Documentation (N) to Looking up Documentation (N): 0.0\n",
      "Probability from Looking up Documentation (N) to Not Thinking (S): 0.0\n",
      "Probability from Looking up Documentation (N) to Prompt Crafting (V): 0.4\n",
      "Probability from Looking up Documentation (N) to Thinking About New Code To Write (F): 0.1\n",
      "Probability from Looking up Documentation (N) to Thinking/Verifying Suggestion (A): 0.1\n",
      "Probability from Looking up Documentation (N) to Waiting For Suggestion (G): 0.1\n",
      "Probability from Looking up Documentation (N) to Writing Documentation (B): 0.0\n",
      "Probability from Looking up Documentation (N) to Writing New Functionality (Z): 0.1\n",
      "Probability from Not Thinking (S) to Debugging/Testing Code (H): 0.0\n",
      "Probability from Not Thinking (S) to Deferring Thought For Later (D): 0.0\n",
      "Probability from Not Thinking (S) to Editing Last Suggestion (X): 0.0\n",
      "Probability from Not Thinking (S) to Editing Written Code(C): 0.0\n",
      "Probability from Not Thinking (S) to Looking up Documentation (N): 0.0\n",
      "Probability from Not Thinking (S) to Not Thinking (S): 0.0\n",
      "Probability from Not Thinking (S) to Prompt Crafting (V): 0.0\n",
      "Probability from Not Thinking (S) to Thinking About New Code To Write (F): 0.0\n",
      "Probability from Not Thinking (S) to Thinking/Verifying Suggestion (A): 0.0\n",
      "Probability from Not Thinking (S) to Waiting For Suggestion (G): 0.0\n",
      "Probability from Not Thinking (S) to Writing Documentation (B): 0.0\n",
      "Probability from Not Thinking (S) to Writing New Functionality (Z): 1.0\n",
      "Probability from Prompt Crafting (V) to Debugging/Testing Code (H): 0.0\n",
      "Probability from Prompt Crafting (V) to Deferring Thought For Later (D): 0.061855670103092786\n",
      "Probability from Prompt Crafting (V) to Editing Last Suggestion (X): 0.010309278350515464\n",
      "Probability from Prompt Crafting (V) to Editing Written Code(C): 0.030927835051546393\n",
      "Probability from Prompt Crafting (V) to Looking up Documentation (N): 0.010309278350515464\n",
      "Probability from Prompt Crafting (V) to Not Thinking (S): 0.0\n",
      "Probability from Prompt Crafting (V) to Prompt Crafting (V): 0.0\n",
      "Probability from Prompt Crafting (V) to Thinking About New Code To Write (F): 0.08247422680412371\n",
      "Probability from Prompt Crafting (V) to Thinking/Verifying Suggestion (A): 0.5360824742268041\n",
      "Probability from Prompt Crafting (V) to Waiting For Suggestion (G): 0.24742268041237114\n",
      "Probability from Prompt Crafting (V) to Writing Documentation (B): 0.0\n",
      "Probability from Prompt Crafting (V) to Writing New Functionality (Z): 0.020618556701030927\n",
      "Probability from Thinking About New Code To Write (F) to Debugging/Testing Code (H): 0.034782608695652174\n",
      "Probability from Thinking About New Code To Write (F) to Deferring Thought For Later (D): 0.05217391304347826\n",
      "Probability from Thinking About New Code To Write (F) to Editing Last Suggestion (X): 0.034782608695652174\n",
      "Probability from Thinking About New Code To Write (F) to Editing Written Code(C): 0.0782608695652174\n",
      "Probability from Thinking About New Code To Write (F) to Looking up Documentation (N): 0.017391304347826087\n",
      "Probability from Thinking About New Code To Write (F) to Not Thinking (S): 0.0\n",
      "Probability from Thinking About New Code To Write (F) to Prompt Crafting (V): 0.13043478260869565\n",
      "Probability from Thinking About New Code To Write (F) to Thinking About New Code To Write (F): 0.0\n",
      "Probability from Thinking About New Code To Write (F) to Thinking/Verifying Suggestion (A): 0.26956521739130435\n",
      "Probability from Thinking About New Code To Write (F) to Waiting For Suggestion (G): 0.05217391304347826\n",
      "Probability from Thinking About New Code To Write (F) to Writing Documentation (B): 0.0\n",
      "Probability from Thinking About New Code To Write (F) to Writing New Functionality (Z): 0.33043478260869563\n",
      "Probability from Thinking/Verifying Suggestion (A) to Debugging/Testing Code (H): 0.06369426751592357\n",
      "Probability from Thinking/Verifying Suggestion (A) to Deferring Thought For Later (D): 0.03503184713375796\n",
      "Probability from Thinking/Verifying Suggestion (A) to Editing Last Suggestion (X): 0.16878980891719744\n",
      "Probability from Thinking/Verifying Suggestion (A) to Editing Written Code(C): 0.022292993630573247\n",
      "Probability from Thinking/Verifying Suggestion (A) to Looking up Documentation (N): 0.006369426751592357\n",
      "Probability from Thinking/Verifying Suggestion (A) to Not Thinking (S): 0.0031847133757961785\n",
      "Probability from Thinking/Verifying Suggestion (A) to Prompt Crafting (V): 0.1178343949044586\n",
      "Probability from Thinking/Verifying Suggestion (A) to Thinking About New Code To Write (F): 0.14012738853503184\n",
      "Probability from Thinking/Verifying Suggestion (A) to Thinking/Verifying Suggestion (A): 0.012738853503184714\n",
      "Probability from Thinking/Verifying Suggestion (A) to Waiting For Suggestion (G): 0.14968152866242038\n",
      "Probability from Thinking/Verifying Suggestion (A) to Writing Documentation (B): 0.01910828025477707\n",
      "Probability from Thinking/Verifying Suggestion (A) to Writing New Functionality (Z): 0.2611464968152866\n",
      "Probability from Waiting For Suggestion (G) to Debugging/Testing Code (H): 0.010416666666666666\n",
      "Probability from Waiting For Suggestion (G) to Deferring Thought For Later (D): 0.125\n",
      "Probability from Waiting For Suggestion (G) to Editing Last Suggestion (X): 0.03125\n",
      "Probability from Waiting For Suggestion (G) to Editing Written Code(C): 0.020833333333333332\n",
      "Probability from Waiting For Suggestion (G) to Looking up Documentation (N): 0.0\n",
      "Probability from Waiting For Suggestion (G) to Not Thinking (S): 0.0\n",
      "Probability from Waiting For Suggestion (G) to Prompt Crafting (V): 0.15625\n",
      "Probability from Waiting For Suggestion (G) to Thinking About New Code To Write (F): 0.020833333333333332\n",
      "Probability from Waiting For Suggestion (G) to Thinking/Verifying Suggestion (A): 0.5104166666666666\n",
      "Probability from Waiting For Suggestion (G) to Waiting For Suggestion (G): 0.0\n",
      "Probability from Waiting For Suggestion (G) to Writing Documentation (B): 0.0\n",
      "Probability from Waiting For Suggestion (G) to Writing New Functionality (Z): 0.125\n",
      "Probability from Writing Documentation (B) to Debugging/Testing Code (H): 0.1111111111111111\n",
      "Probability from Writing Documentation (B) to Deferring Thought For Later (D): 0.0\n",
      "Probability from Writing Documentation (B) to Editing Last Suggestion (X): 0.1111111111111111\n",
      "Probability from Writing Documentation (B) to Editing Written Code(C): 0.0\n",
      "Probability from Writing Documentation (B) to Looking up Documentation (N): 0.0\n",
      "Probability from Writing Documentation (B) to Not Thinking (S): 0.0\n",
      "Probability from Writing Documentation (B) to Prompt Crafting (V): 0.1111111111111111\n",
      "Probability from Writing Documentation (B) to Thinking About New Code To Write (F): 0.1111111111111111\n",
      "Probability from Writing Documentation (B) to Thinking/Verifying Suggestion (A): 0.2222222222222222\n",
      "Probability from Writing Documentation (B) to Waiting For Suggestion (G): 0.1111111111111111\n",
      "Probability from Writing Documentation (B) to Writing Documentation (B): 0.0\n",
      "Probability from Writing Documentation (B) to Writing New Functionality (Z): 0.2222222222222222\n",
      "Probability from Writing New Functionality (Z) to Debugging/Testing Code (H): 0.011363636363636364\n",
      "Probability from Writing New Functionality (Z) to Deferring Thought For Later (D): 0.10227272727272728\n",
      "Probability from Writing New Functionality (Z) to Editing Last Suggestion (X): 0.005681818181818182\n",
      "Probability from Writing New Functionality (Z) to Editing Written Code(C): 0.045454545454545456\n",
      "Probability from Writing New Functionality (Z) to Looking up Documentation (N): 0.005681818181818182\n",
      "Probability from Writing New Functionality (Z) to Not Thinking (S): 0.0\n",
      "Probability from Writing New Functionality (Z) to Prompt Crafting (V): 0.028409090909090908\n",
      "Probability from Writing New Functionality (Z) to Thinking About New Code To Write (F): 0.1590909090909091\n",
      "Probability from Writing New Functionality (Z) to Thinking/Verifying Suggestion (A): 0.5909090909090909\n",
      "Probability from Writing New Functionality (Z) to Waiting For Suggestion (G): 0.045454545454545456\n",
      "Probability from Writing New Functionality (Z) to Writing Documentation (B): 0.0\n",
      "Probability from Writing New Functionality (Z) to Writing New Functionality (Z): 0.005681818181818182\n"
     ]
    }
   ],
   "source": [
    "for i, from_state in enumerate(nodes_original):\n",
    "    for j, to_state in enumerate(nodes_original):\n",
    "        print(f\"Probability from {from_state} to {to_state}: {transition_matrix[i][j]}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Debugging/Testing Code (H) --- 0.31 ---> Thinking/Verifying Suggestion (A)\n",
      " Deferring Thought For Later (D) --- 0.54 ---> Thinking/Verifying Suggestion (A)\n",
      " Editing Last Suggestion (X) --- 0.26 ---> Thinking About New Code To Write (F)\n",
      " Editing Written Code(C) --- 0.29 ---> Writing New Functionality (Z)\n",
      " Looking up Documentation (N) --- 0.40 ---> Prompt Crafting (V)\n",
      " Not Thinking (S) --- 1.00 ---> Writing New Functionality (Z)\n",
      " Prompt Crafting (V) --- 0.54 ---> Thinking/Verifying Suggestion (A)\n",
      " Thinking About New Code To Write (F) --- 0.33 ---> Writing New Functionality (Z)\n",
      " Thinking/Verifying Suggestion (A) --- 0.26 ---> Writing New Functionality (Z)\n",
      " Waiting For Suggestion (G) --- 0.51 ---> Thinking/Verifying Suggestion (A)\n",
      " Writing Documentation (B) --- 0.22 ---> Thinking/Verifying Suggestion (A)\n",
      " Writing New Functionality (Z) --- 0.59 ---> Thinking/Verifying Suggestion (A)\n"
     ]
    }
   ],
   "source": [
    "# find most probable transition from each state\n",
    "# find most probable transition from each state\n",
    "\n",
    "for i in range(len(transition_matrix)):\n",
    "    # find max value in ro\n",
    "    max_val = max(transition_matrix[i])\n",
    "    # find index of max value in row\n",
    "    max_val_index = transition_matrix[i].tolist().index(max_val)\n",
    "    # add to dict\n",
    "    print(f' {nodes[i]} --- {transition_matrix[i][max_val_index]:.2f} ---> {nodes[max_val_index]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.43790289]\n"
     ]
    }
   ],
   "source": [
    "mu = stationary_distribution(transition_matrix)\n",
    "# get entropy rate of the MC\n",
    "entropy_rate = np.dot(mu.transpose(), local_entropy(transition_matrix))\n",
    "print(entropy_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "uniform_transition_matrix = np.ones((len(transition_matrix), len(transition_matrix)))/len(transition_matrix)\n",
    "\n",
    "mu = stationary_distribution(uniform_transition_matrix)\n",
    "# uniform transition matrix\n",
    "# get entropy rate of the MC\n",
    "entropy_rate = np.dot(mu.transpose(), local_entropy(uniform_transition_matrix))\n",
    "print(entropy_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# find most probable transition from each state\n",
    "nodes_original = list(graph.dataframe.index)\n",
    "\n",
    "for i in range(len(transition_matrix)):\n",
    "    # find top 2 values in row\n",
    "    top_2_values = sorted(transition_matrix[i], reverse=True)[:2]\n",
    "    # find indices of top 2 values in row\n",
    "    top_2_values_indices = [transition_matrix[i].tolist().index(x) for x in top_2_values]\n",
    "\n",
    "    # add to dict\n",
    "    print(f' {nodes_original[i]} --- {transition_matrix[i][top_2_values_indices[1]]:.2f} ---> {nodes_original[top_2_values_indices[1]]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find most probable sequences\n",
    "from scipy.stats import itemfreq\n",
    "N = 3\n",
    "def list_to_string(lst):\n",
    "    return ' -> '.join(lst)\n",
    "grams = [list_to_string(all_states_continuous[i:i+N]) for i in range(len(all_states_continuous)-N)]\n",
    "# counter from grams\n",
    "from collections import Counter\n",
    "counter_grams = Counter(grams)\n",
    "# get most common grams\n",
    "most_common_grams = counter_grams.most_common(10)\n",
    "# print each on new line\n",
    "for i in range(len(most_common_grams)):\n",
    "    print(most_common_grams[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_states_augmented = [] \n",
    "for i in range(len(logs_by_user_session_labeled)):\n",
    "    states = logs_by_user_session_labeled[i].LabeledState.to_numpy()\n",
    "    actions = logs_by_user_session_labeled[i].StateName.to_numpy()\n",
    "    times = logs_by_user_session_labeled[i].TimeSpentInState.to_numpy()\n",
    "    # clean up states\n",
    "    for j in range(len(states)):\n",
    "        if states[j] == 'IDK':\n",
    "            states[j] = 'IDK (I)'\n",
    "        if states[j] == 'Looking up documentation' or states[j] == 'Looking up documentation (N)':\n",
    "            states[j] = 'Looking up Documentation (N)'\n",
    "        if states[j] == 'h':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "        if states[j] == 'Thinking about new code to write (F)':\n",
    "            states[j] = 'Thinking About New Code To Write (F)'\n",
    "\n",
    "    # get indices where state is IDK\n",
    "    idk_indices = [i for i in range(len(states)) if states[i] == 'IDK (I)']\n",
    "    states = [states[i] for i in range(len(states)) if i not in idk_indices]\n",
    "    actions = [actions[i] for i in range(len(actions)) if i not in idk_indices]\n",
    "    times = [times[i] for i in range(len(times)) if i not in idk_indices]\n",
    "\n",
    "    states_continuous = []\n",
    "    times_continuous = []\n",
    "    # merge states with same name\n",
    "    last_state = states[0]\n",
    "    times_cumalitive = 0\n",
    "    for i in range(len(states)):\n",
    "        all_states_augmented.append(states[i])\n",
    "        if actions[i] != 'Replay':\n",
    "            all_states_augmented.append(actions[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find most probable sequences\n",
    "from scipy.stats import itemfreq\n",
    "N = 6\n",
    "def list_to_string(lst):\n",
    "    return ' -> '.join(lst)\n",
    "grams = [list_to_string(all_states_augmented[i:i+N]) for i in range(len(all_states_augmented)-N)]\n",
    "# counter from grams\n",
    "from collections import Counter\n",
    "counter_grams = Counter(grams)\n",
    "# get most common grams\n",
    "most_common_grams = counter_grams.most_common(50)\n",
    "# print each on new line\n",
    "for i in range(len(most_common_grams)):\n",
    "    print(most_common_grams[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find most probable sequences\n",
    "from scipy.stats import itemfreq\n",
    "N = 5\n",
    "def list_to_string(lst):\n",
    "    return ' -> '.join(lst)\n",
    "grams = [list_to_string(all_states_augmented[i:i+N]) for i in range(len(all_states_augmented)-N)]\n",
    "# counter from grams\n",
    "from collections import Counter\n",
    "counter_grams = Counter(grams)\n",
    "# get most common grams\n",
    "most_common_grams = counter_grams.most_common(10)\n",
    "# print each on new line\n",
    "for i in range(len(most_common_grams)):\n",
    "    print(most_common_grams[i])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# p value correction\n",
    "p_values = [0.56,0,0,8*10**-6,4*10**-5]\n",
    "from statsmodels.stats.multitest import multipletests\n",
    "multipletests(p_values, alpha=0.05, method='fdr_bh', is_sorted=False, returnsorted=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('hussein': conda)",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e710af216e809473b1f2bcdee939ed3d8fc69fba0a18fe13b179176696cffea0"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}