Labeling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/kutsenok/opt/anaconda3/envs/Inquiry_exp/lib/python3.9/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.23.5\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "from pathlib import Path\n",
    "import numpy as np\n",
    "import re\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Label the actions with separate explore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def records_func(state_action):\n",
    "    records = []\n",
    "    rec_num = 0\n",
    "\n",
    "    for i in range(len(state_action['new_seq']['actions']['action'])):\n",
    "        if state_action['new_seq']['actions']['action'][i] == 'record':\n",
    "            rec = {'Rec No': rec_num, 'Width': state_action['new_seq']['state']['width'][i], 'Concentration': state_action['new_seq']['state']['concentration'][i], 'Wavelength': state_action['new_seq']['state']['wavelength'][i], 'Solution': state_action['new_seq']['state']['solution'][i]}\n",
    "            records.append(rec)\n",
    "            rec_num += 1\n",
    "\n",
    "    return records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def categorise_record_based_on_previous_record_v1(state_action):\n",
    "\n",
    "    record_num = 0\n",
    "    records = records_func(state_action)\n",
    "    \n",
    "    for i in range(len(state_action['new_seq']['actions']['action'])):\n",
    "        if state_action['new_seq']['actions']['action'][i] == 'record':\n",
    "            if record_num == 0:\n",
    "                record_num += 1\n",
    "            else:\n",
    "                label_rec = 'record'\n",
    "                if records[record_num]['Width'] != records[record_num - 1]['Width']:\n",
    "                    label_rec += '_width'\n",
    "                if records[record_num]['Concentration'] != records[record_num - 1]['Concentration']:\n",
    "                    label_rec += '_concentration'\n",
    "                if records[record_num]['Wavelength'] != records[record_num - 1]['Wavelength']:\n",
    "                    label_rec += '_wavelength'\n",
    "                if records[record_num]['Solution'] != records[record_num - 1]['Solution']:\n",
    "                    label_rec += '_solution'\n",
    "                state_action['new_seq']['actions']['action'][i] = label_rec\n",
    "                record_num += 1\n",
    "    #return state_action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def graph_func(sim_data):\n",
    "    graph = {'action': [], 'timestamp': [], 'xaxis_value': [None], 'yaxis_value': [None]}\n",
    "\n",
    "    for i in range(len(sim_data['logs'])):\n",
    "            if sim_data['logs'][i]['action'] in ['xaxis', 'yaxis']:\n",
    "                graph['action'].append(sim_data['logs'][i]['action'])\n",
    "                graph['timestamp'].append(sim_data['logs'][i]['timestamp'])\n",
    "                if sim_data['logs'][i]['action'] == 'xaxis':\n",
    "                    if sim_data['logs'][i]['new_value'] == 'cuvetteWidth':\n",
    "                         graph['xaxis_value'].append('width')\n",
    "                    elif sim_data['logs'][i]['new_value'] == 'trialNumber':\n",
    "                        graph['xaxis_value'].append('other')\n",
    "                    else:\n",
    "                        graph['xaxis_value'].append(sim_data['logs'][i]['new_value'])\n",
    "                    graph['yaxis_value'].append(graph['yaxis_value'][-1])\n",
    "                elif sim_data['logs'][i]['action'] == 'yaxis':\n",
    "                    if sim_data['logs'][i]['new_value'] == 'cuvetteWidth':\n",
    "                         graph['yaxis_value'].append('width')\n",
    "                    elif sim_data['logs'][i]['new_value'] == 'trialNumber':\n",
    "                        graph['yaxis_value'].append('other')\n",
    "                    else:\n",
    "                        graph['yaxis_value'].append(sim_data['logs'][i]['new_value'])\n",
    "                    graph['xaxis_value'].append(graph['xaxis_value'][-1])\n",
    "                else:\n",
    "                    graph['xaxis_value'].append(graph['xaxis_value'][-1])\n",
    "                    graph['yaxis_value'].append(graph['yaxis_value'][-1])\n",
    "                    \n",
    "    return graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def categorise_analysis_action(state_action, graph):\n",
    "\n",
    "    new_actions = []\n",
    "\n",
    "    for i in range(len(state_action['new_seq']['actions']['action'])):\n",
    "        if state_action['new_seq']['actions']['action'][i] == 'plot':\n",
    "            timestamp = state_action['new_seq']['actions']['timestamp'][i]\n",
    "            yaxis_value = None\n",
    "            xaxis_value = None\n",
    "\n",
    "            if timestamp > graph['timestamp'][-1]:\n",
    "                xaxis_value = graph['xaxis_value'][-1]\n",
    "                yaxis_value = graph['yaxis_value'][-1]\n",
    "            else:\n",
    "                for i in range(len(graph['timestamp'])):\n",
    "                    if graph['timestamp'][i] > timestamp:\n",
    "                        xaxis_value = graph['xaxis_value'][i]\n",
    "                        yaxis_value = graph['yaxis_value'][i]\n",
    "                        break\n",
    "                    \n",
    "            if xaxis_value is not None and yaxis_value == 'absorbance' and xaxis_value != 'absorbance':\n",
    "                new_actions.append('analysis_plot_{0}'.format(xaxis_value))\n",
    "            elif yaxis_value is not None and xaxis_value == 'absorbance' and yaxis_value != 'absorbance':\n",
    "                new_actions.append('analysis_plot_{0}'.format(yaxis_value))\n",
    "            else:\n",
    "                new_actions.append('analysis_plot_other')\n",
    "        elif state_action['new_seq']['actions']['action'][i] in ['delete_point_from_table', 'move_down_point', 'move_up_point']:\n",
    "            new_actions.append('analysis_table')\n",
    "        elif state_action['new_seq']['actions']['action'][i] in ['xaxis', 'yaxis', 'xaxis_scale', 'yaxis_scale']:\n",
    "            new_actions.append('analysis_axis')\n",
    "        elif state_action['new_seq']['actions']['action'][i] == 'remove_from_graph':\n",
    "            new_actions.append('analysis_remove')\n",
    "        else:\n",
    "            new_actions.append(state_action['new_seq']['actions']['action'][i])\n",
    "\n",
    "    state_action['new_seq']['actions']['action'] = new_actions\n",
    "\n",
    "    #return state_action"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labelling_exploring_segment_v1(segment):\n",
    "    label = 'explore'\n",
    "    if 'width' in segment:\n",
    "            label += '_width'\n",
    "\n",
    "    if 'concentration' in segment:\n",
    "        label += '_concentration'\n",
    "    \n",
    "    if 'wavelength' in segment:\n",
    "        label += '_wavelength'\n",
    "\n",
    "    if 'solution' in segment: \n",
    "        label += '_solution'\n",
    "\n",
    "    if 'open_instruction' in segment or 'close_instruction' in segment or 'ruler' in segment or 'restore_sim' in segment or 'open_solution_menu' in segment:\n",
    "        label += '_other'\n",
    "\n",
    "    return label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def labelling_exploring_variable_v1(state_action, threshold = 3000):\n",
    "    segment = []\n",
    "    new_actions = []\n",
    "    new_begins = []\n",
    "    new_ends = []\n",
    "    current_action_in_segment = None\n",
    "    actions = state_action['new_seq']['actions']['action']\n",
    "    timestamp = state_action['new_seq']['actions']['timestamp']\n",
    "\n",
    "    for i in range(len(actions)-1):\n",
    "        if 'analysis' in actions[i] or 'record'in actions[i]:\n",
    "            if segment != []:\n",
    "                labelled_segment = labelling_exploring_segment_v1(segment)\n",
    "                new_actions.append(labelled_segment)\n",
    "                current_action_in_segment = None\n",
    "                segment = []\n",
    "            new_actions.append(actions[i])\n",
    "            new_begins.append(timestamp[i])\n",
    "            new_ends.append(timestamp[i])\n",
    "        \n",
    "        elif segment != []:\n",
    "            if timestamp[i] - new_ends[-1] <= threshold and actions[i] == current_action_in_segment:\n",
    "                new_ends[-1] = timestamp[i]\n",
    "                segment.append(actions[i])\n",
    "            else:\n",
    "                labelled_segment = labelling_exploring_segment_v1(segment)\n",
    "                new_actions.append(labelled_segment)\n",
    "                current_action_in_segment = actions[i]\n",
    "\n",
    "                segment = [actions[i]]\n",
    "                new_begins.append(timestamp[i])\n",
    "                new_ends.append(timestamp[i])\n",
    "\n",
    "        else:\n",
    "            segment.append(actions[i])\n",
    "            new_begins.append(timestamp[i])\n",
    "            new_ends.append(timestamp[i])\n",
    "            current_action_in_segment = actions[i]\n",
    "\n",
    "    if segment != []:\n",
    "        labelled_segment = labelling_exploring_segment_v1(segment)\n",
    "        new_actions.append(labelled_segment)\n",
    "\n",
    "    result = [[new_actions[i], new_begins[i], new_ends[i]] for i in range(len(new_actions))]\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_breaks(result, break_threshold=20000):\n",
    "    result_duplicate = [result[0]]\n",
    "    for i in range(1, len(result)):\n",
    "        if result[i][1] - result[i-1][2] >= break_threshold:\n",
    "            break_length = result[i][1] - result[i-1][2]\n",
    "            break_num = break_length // break_threshold\n",
    "            break_begin = result[i-1][2]\n",
    "            for j in range(int(break_num)):\n",
    "                result_duplicate.append(['break', break_begin, break_begin + break_threshold])\n",
    "                break_begin += break_threshold\n",
    "            result_duplicate.append(result[i])\n",
    "        else:\n",
    "            result_duplicate.append(result[i])\n",
    "    return result_duplicate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variables_sequencer_v1(state_action, sim_data, threshold = 3000):\n",
    "    categorise_record_based_on_previous_record_v1(state_action)\n",
    "    graph = graph_func(sim_data)\n",
    "    categorise_analysis_action(state_action, graph)\n",
    "    result = labelling_exploring_variable_v1(state_action, threshold = threshold)\n",
    "    final_result = insert_breaks(result, break_threshold=20000)\n",
    "\n",
    "    fin_result = {'group': state_action['group'], 'subgroup': state_action['subgroup'], 'session_code': state_action['session_code'], 'task': state_action['task'], 'var_seq_v1': final_result}\n",
    "\n",
    "    return fin_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Labeling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CVS labeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cvs_labeling(separate_actions_check, st_act_check):    \n",
    "    cvs_try = separate_actions_check['actions'].copy()\n",
    "\n",
    "    for i in range(len(cvs_try)):\n",
    "        if separate_actions_check['actions'][i] == 'explore_solution':\n",
    "            solution_experiment = []\n",
    "            for j in range(i+1, len(cvs_try)):\n",
    "                if separate_actions_check['actions'][j] == 'explore_solution':\n",
    "                    for k in range(i, j):\n",
    "                        solution_experiment.append(separate_actions_check['actions'][k])\n",
    "\n",
    "                    if (sum('explore_concentration' in k for k in solution_experiment) > 1) or (sum('explore_wavelength' in k for k in solution_experiment) > 1) or 'explore_width' in solution_experiment:\n",
    "                        for m in range(len(solution_experiment)):\n",
    "                            if solution_experiment[m] == 'explore_solution':\n",
    "                                cvs_try[i+m] = 'Non_CVS_explore_solution'\n",
    "                        solution_experiment = []\n",
    "\n",
    "                    else:\n",
    "                        for m in range(len(st_act_check['new_seq']['actions']['timestamp'])):\n",
    "                            if separate_actions_check['begins'][i] == st_act_check['new_seq']['actions']['timestamp'][m]:\n",
    "                                concentration_sol = st_act_check['new_seq']['state']['concentration'][m]\n",
    "                                wavelength_sol = st_act_check['new_seq']['state']['wavelength'][m]\n",
    "                            if separate_actions_check['ends'][i+len(solution_experiment)-1] == st_act_check['new_seq']['actions']['timestamp'][m]:\n",
    "                                concentration_final = st_act_check['new_seq']['state']['concentration'][m]\n",
    "                                wavelength_final = st_act_check['new_seq']['state']['wavelength'][m]\n",
    "\n",
    "                        try:    \n",
    "                            if concentration_sol != 0 and (concentration_sol % concentration_final == 0) and wavelength_sol == wavelength_final:\n",
    "                                for m in range(len(solution_experiment)):\n",
    "                                    if solution_experiment[m] == 'explore_solution':\n",
    "                                        cvs_try[i+m] = 'CVS_explore_solution'\n",
    "                                    elif 'record' in solution_experiment[m]:\n",
    "                                        cvs_try[i+m] = 'CVS_record_solution'\n",
    "                                    elif solution_experiment[m] in ['explore_concentration', 'explore_wavelength', 'explore_other']:\n",
    "                                        cvs_try[i+m] = 'other'\n",
    "                            else:\n",
    "                                for m in range(len(solution_experiment)):\n",
    "                                    if solution_experiment[m] == 'explore_solution':\n",
    "                                        cvs_try[i+m] = 'Non_CVS_explore_solution'\n",
    "                                    elif 'record' in solution_experiment[m]:\n",
    "                                        cvs_try[i+m] = 'Non_CVS_record_solution'\n",
    "                                    elif solution_experiment[m] in ['explore_concentration', 'explore_wavelength', 'explore_other']:\n",
    "                                        cvs_try[i+m] = 'other'\n",
    "                        except ZeroDivisionError:\n",
    "                            if concentration_sol == concentration_final and wavelength_sol == wavelength_final:\n",
    "                                for m in range(len(solution_experiment)):\n",
    "                                    if solution_experiment[m] == 'explore_solution':\n",
    "                                        cvs_try[i+m] = 'CVS_explore_solution'\n",
    "                                    elif 'record' in solution_experiment[m]:\n",
    "                                        cvs_try[i+m] = 'CVS_record_solution'\n",
    "                                    elif solution_experiment[m] in ['explore_concentration', 'explore_wavelength', 'explore_other']:\n",
    "                                        cvs_try[i+m] = 'other'\n",
    "                            else:\n",
    "                                for m in range(len(solution_experiment)):\n",
    "                                    if solution_experiment[m] == 'explore_solution':\n",
    "                                        cvs_try[i+m] = 'Non_CVS_explore_solution'\n",
    "                                    elif 'record' in solution_experiment[m]:\n",
    "                                        cvs_try[i+m] = 'Non_CVS_record_solution'\n",
    "                                    elif solution_experiment[m] in ['explore_concentration', 'explore_wavelength', 'explore_other']:\n",
    "                                        cvs_try[i+m] = 'other'\n",
    "                                        \n",
    "                        solution_experiment = [] \n",
    "\n",
    "                    break   \n",
    "   \n",
    "    for i in range(len(cvs_try)):\n",
    "        if cvs_try[i] == 'explore_solution':\n",
    "            cvs_try[i] = 'Non_CVS_explore_solution'\n",
    "\n",
    "            \n",
    "    for i in range(len(cvs_try)):\n",
    "        if cvs_try[i] in ['explore_concentration', 'explore_wavelength', 'explore_width']:\n",
    "            try:\n",
    "                if cvs_try[i+1] in ['explore_concentration', 'explore_wavelength', 'explore_width']:\n",
    "                    if separate_actions_check['begins'][i+1] - separate_actions_check['ends'][i] <= 3000:\n",
    "                        cvs_try[i] = 'Non_CVS_' + cvs_try[i]\n",
    "                        cvs_try[i+1] = 'Non_CVS_' + cvs_try[i+1]\n",
    "                    else:\n",
    "                        cvs_try[i] = 'CVS_' + cvs_try[i]\n",
    "                else:\n",
    "                    if 'CVS' in cvs_try[i]:\n",
    "                        pass\n",
    "                    else:\n",
    "                        cvs_try[i] = 'CVS_' + cvs_try[i]\n",
    "            except IndexError:\n",
    "                cvs_try[i] = 'CVS_' + cvs_try[i]\n",
    "\n",
    "    for i in range(len(cvs_try)):\n",
    "        if 'record' in cvs_try[i] and cvs_try[i] not in ['CVS_record_solution', 'Non_CVS_record_solution']:\n",
    "            if i-1 >= 0 and i+1 < len(cvs_try):\n",
    "                if cvs_try[i-1] in ['Non_CVS_explore_width', 'Non_CVS_explore_concentration', 'Non_CVS_explore_wavelength'] and cvs_try[i+1] in ['CVS_explore_width', 'CVS_explore_concentration', 'CVS_explore_wavelength']:\n",
    "                    if cvs_try[i-1].replace(\"Non_CVS_\", \"\") == cvs_try[i+1].replace(\"CVS_\", \"\"):\n",
    "                        cvs_try[i] = 'CVS_record_' + cvs_try[i-1].replace(\"Non_CVS_explore_\", \"\")\n",
    "                    else:\n",
    "                        cvs_try[i] = 'Non_CVS_record_' + cvs_try[i-1].replace(\"Non_CVS_explore_\", \"\")\n",
    "                elif cvs_try[i-1] in ['CVS_explore_width', 'CVS_explore_concentration', 'CVS_explore_wavelength']:\n",
    "                    cvs_try[i] = 'CVS_record_' + cvs_try[i-1].replace(\"CVS_explore_\", \"\")\n",
    "                \n",
    "                elif cvs_try[i-1] in ['Non_CVS_explore_width', 'Non_CVS_explore_concentration', 'Non_CVS_explore_wavelength']:\n",
    "                    cvs_try[i] = 'Non_CVS_record_' + cvs_try[i-1].replace(\"Non_CVS_explore_\", \"\")\n",
    "                else:        \n",
    "                    cvs_try[i] = 'Non_CVS_record'\n",
    "            \n",
    "            elif i-1 >= 0:\n",
    "                if cvs_try[i-1] in ['CVS_explore_width', 'CVS_explore_concentration', 'CVS_explore_wavelength']:\n",
    "                    cvs_try[i] = 'CVS_record_' + cvs_try[i-1].replace(\"CVS_explore_\", \"\")\n",
    "                \n",
    "                elif cvs_try[i-1] in ['Non_CVS_explore_width', 'Non_CVS_explore_concentration', 'Non_CVS_explore_wavelength']:\n",
    "                    cvs_try[i] = 'Non_CVS_record_' + cvs_try[i-1].replace(\"Non_CVS_explore_\", \"\")\n",
    "\n",
    "                else:        \n",
    "                    cvs_try[i] = 'Non_CVS_record'\n",
    "                    \n",
    "            else:        \n",
    "                cvs_try[i] = 'Non_CVS_record'\n",
    "\n",
    "    for i in range(len(cvs_try)):\n",
    "        if cvs_try[i] == 'explore_other':\n",
    "            cvs_try[i] = 'other'  \n",
    "\n",
    "    return cvs_try      \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimal labeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimal_labeling(cvs_try, separate_actions_check, st_act_check):\n",
    "    optimal_try = []\n",
    "    for i in range(len(cvs_try)):\n",
    "        if cvs_try[i] in ['CVS_explore_width', 'Non_CVS_explore_width', 'CVS_record_width', 'Non_CVS_record_width']:\n",
    "            for j in range(len(st_act_check['new_seq']['actions']['timestamp'])):\n",
    "                if separate_actions_check['begins'][i] == st_act_check['new_seq']['actions']['timestamp'][j]:\n",
    "                    concentration = st_act_check['new_seq']['state']['concentration'][j]\n",
    "                    wavelength = st_act_check['new_seq']['state']['wavelength'][j]\n",
    "                    solution = st_act_check['new_seq']['state']['solution'][j]\n",
    "\n",
    "                    if solution == 'drink Mix (red)' or solution == 'Cobalt nitrate (red)' or solution == 'Cobalt chloride (red)':\n",
    "                        if wavelength not in range(620, 780) and concentration != 0:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_width')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Non_Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_width')\n",
    "                    elif solution == 'Copper sulfate (blue)':\n",
    "                        if wavelength not in range(450, 495) and concentration != 0:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_width')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Non_Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_width')\n",
    "                    elif solution == 'Nickel chloride (green)':\n",
    "                        if wavelength not in range(495, 570) and concentration != 0:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_width')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Non_Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_width')\n",
    "                    elif solution == 'Potassium chromate (yellow)':\n",
    "                        if wavelength not in range(570, 590) and concentration != 0:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_width')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Non_Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_width')\n",
    "                    elif solution == 'Potassium dichromate (orange)':\n",
    "                        if wavelength not in range(590, 620) and concentration != 0:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_width')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Non_Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_width')\n",
    "                    elif solution == 'Potassium permanganate (purple)':\n",
    "                        if wavelength not in range(620, 700) and concentration != 0:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_width')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_width', 'Non_CVS_record_width']:\n",
    "                                optimal_try.append('Non_Optimal_record_width')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_width')\n",
    "\n",
    "                    concentration = None\n",
    "                    wavelength = None\n",
    "                    solution = None\n",
    "\n",
    "        elif cvs_try[i] in ['CVS_explore_concentration', 'Non_CVS_explore_concentration', 'CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "            for j in range(len(st_act_check['new_seq']['actions']['timestamp'])):\n",
    "                if separate_actions_check['begins'][i] == st_act_check['new_seq']['actions']['timestamp'][j]:\n",
    "                    wavelength = st_act_check['new_seq']['state']['wavelength'][j]\n",
    "                    solution = st_act_check['new_seq']['state']['solution'][j]\n",
    "\n",
    "                    if solution == 'drink Mix (red)' or solution == 'Cobalt nitrate (red)' or solution == 'Cobalt chloride (red)':\n",
    "                        if wavelength not in range(620, 780):\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_concentration')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Non_Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_concentration')\n",
    "                    elif solution == 'Copper sulfate (blue)':\n",
    "                        if wavelength not in range(450, 495):\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_concentration')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Non_Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_concentration')\n",
    "                    elif solution == 'Nickel chloride (green)':\n",
    "                        if wavelength not in range(495, 570):\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_concentration')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Non_Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_concentration')\n",
    "                    elif solution == 'Potassium chromate (yellow)':\n",
    "                        if wavelength not in range(570, 590):\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_concentration')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Non_Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_concentration')\n",
    "                    elif solution == 'Potassium dichromate (orange)':\n",
    "                        if wavelength not in range(590, 620):\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_concentration')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Non_Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_concentration')\n",
    "                    elif solution == 'Potassium permanganate (purple)':\n",
    "                        if wavelength not in range(620, 700):\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Optimal_explore_concentration')\n",
    "                        else:\n",
    "                            if cvs_try[i] in ['CVS_record_concentration', 'Non_CVS_record_concentration']:\n",
    "                                optimal_try.append('Non_Optimal_record_concentration')\n",
    "                            else:\n",
    "                                optimal_try.append('Non_Optimal_explore_concentration')\n",
    "\n",
    "                    wavelength = None\n",
    "                    solution = None\n",
    "\n",
    "        elif cvs_try[i] in ['CVS_explore_wavelength', 'Non_CVS_explore_wavelength', 'CVS_record_wavelength', 'Non_CVS_record_wavelength']:\n",
    "            for j in range(len(st_act_check['new_seq']['actions']['timestamp'])):\n",
    "                if separate_actions_check['begins'][i] == st_act_check['new_seq']['actions']['timestamp'][j]:\n",
    "                    concentration = st_act_check['new_seq']['state']['concentration'][j]\n",
    "\n",
    "                    if concentration != 0:\n",
    "                        if cvs_try[i] in ['CVS_record_wavelength', 'Non_CVS_record_wavelength']:\n",
    "                            optimal_try.append('Optimal_record_wavelength')\n",
    "                        else:\n",
    "                            optimal_try.append('Optimal_explore_wavelength')\n",
    "                    else:\n",
    "                        if cvs_try[i] in ['CVS_record_wavelength', 'Non_CVS_record_wavelength']:\n",
    "                            optimal_try.append('Non_Optimal_record_wavelength')\n",
    "                        else:\n",
    "                            optimal_try.append('Non_Optimal_explore_wavelength')\n",
    "\n",
    "                    concentration = None\n",
    "\n",
    "        elif cvs_try[i] in ['Non_CVS_record', 'Non_CVS_record_solution', 'CVS_record_solution']:\n",
    "            optimal_try.append(re.sub(r'^(CVS_|Non_CVS_)', '', cvs_try[i]))\n",
    "        elif cvs_try[i] in ['CVS_explore_solution', 'Non_CVS_explore_solution']:\n",
    "            optimal_try.append('solution')\n",
    "            \n",
    "        else:\n",
    "            optimal_try.append(cvs_try[i])\n",
    "            \n",
    "    return optimal_try"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Range labeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ranger_stop(st_act, experiment_begin, experiment_end, current_variable):\n",
    "    state_data = st_act['new_seq']['state']\n",
    "    timestamp = st_act['new_seq']['actions']['timestamp']\n",
    "\n",
    "    experiment_values = []\n",
    "    previous_timestamp = None\n",
    "\n",
    "    for j in range(len(timestamp)):\n",
    "        if timestamp[j] >= experiment_begin and timestamp[j] <= experiment_end:\n",
    "            if timestamp[j] == previous_timestamp:\n",
    "                continue # Skip to the next iteration\n",
    "            # If not equal, append the value to the list\n",
    "            experiment_values.append(state_data[current_variable][j+1])\n",
    "            previous_timestamp = timestamp[j]\n",
    "            solution = state_data['solution'][j]\n",
    "\n",
    "    explore_times = []\n",
    "    stop_counter = 0\n",
    "    \n",
    "    for j in range(len(timestamp)):\n",
    "        if timestamp[j] >= experiment_begin and timestamp[j] <= experiment_end:\n",
    "            if timestamp[j] == previous_timestamp:\n",
    "                continue\n",
    "\n",
    "            if 'record' not in st_act['new_seq']['actions']['action'][j]:\n",
    "                explore_times.append(timestamp[j])\n",
    "            else:\n",
    "                if len(explore_times) != 0:\n",
    "                    for m in range(len(explore_times)-1):\n",
    "                        if (explore_times[m+1] - explore_times[m]) > 20:\n",
    "                            stop_counter += 1\n",
    "                    explore_times = []\n",
    "\n",
    "    if len(explore_times) != 0:\n",
    "        for m in range(len(explore_times)-1):\n",
    "            if (explore_times[m+1] - explore_times[m]) > 20:\n",
    "                stop_counter += 1\n",
    "        explore_times = []        \n",
    "\n",
    "    min_value = np.min(experiment_values)\n",
    "    max_value = np.max(experiment_values)\n",
    "\n",
    "    range_perc = (max_value - min_value)\n",
    "\n",
    "    if current_variable == 'width':\n",
    "        range_perc /= 1.5\n",
    "        \n",
    "    elif current_variable == 'concentration':\n",
    "        concentration_division = {\n",
    "            'drink Mix (red)': 0.4,\n",
    "            'Cobalt nitrate (red)': 0.4,\n",
    "            'Cobalt chloride (red)': 0.25,\n",
    "            'Copper sulfate (blue)': 0.2,\n",
    "            'Nickel chloride (green)': 0.35,\n",
    "            'Potassium chromate (yellow)': 0.0004,\n",
    "            'Potassium dichromate (orange)': 0.0005,\n",
    "            'Potassium permanganate (purple)': 0.0008\n",
    "        }\n",
    "        range_perc /= concentration_division.get(solution)\n",
    "\n",
    "    elif current_variable == 'wavelength':\n",
    "        range_perc /= 400\n",
    "\n",
    "    return round(range_perc*100, 2), stop_counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def range_labeling_stop(cvs_try, separate_actions_check, st_act_check):\n",
    "    range_try = cvs_try.copy()\n",
    "    experiment = []\n",
    "    solutions = ['drink Mix (red)']\n",
    "\n",
    "    for i in range(len(cvs_try)):\n",
    "        if experiment == []:\n",
    "            if cvs_try[i] in ['CVS_explore_width', 'Non_CVS_explore_width', 'CVS_explore_concentration', 'Non_CVS_explore_concentration', 'CVS_explore_wavelength', 'Non_CVS_explore_wavelength']:\n",
    "                experiment.append(cvs_try[i])\n",
    "                experiment_begin = separate_actions_check['begins'][i]\n",
    "                experiment_end = separate_actions_check['ends'][i]\n",
    "                begin_index = i\n",
    "                end_index = i\n",
    "                current_variable = re.sub(r'^(CVS_explore_|Non_CVS_explore_)', '', cvs_try[i]) #removes CVS_exlpore_ or Non_CVS_explore_ from the beginning of the string\n",
    "        else:\n",
    "            if cvs_try[i] in ['CVS_explore_width', 'Non_CVS_explore_width', 'CVS_explore_concentration', 'Non_CVS_explore_concentration', 'CVS_explore_wavelength', 'Non_CVS_explore_wavelength']:\n",
    "                if current_variable == re.sub(r'^(CVS_explore_|Non_CVS_explore_)', '', cvs_try[i]):\n",
    "                    experiment.append(cvs_try[i])\n",
    "                    experiment_end = separate_actions_check['ends'][i]\n",
    "                    end_index = i\n",
    "                else:\n",
    "                    step_counter = sum('record' in k for k in experiment)\n",
    "                    range_perc, stops = ranger_stop(st_act_check, experiment_begin, experiment_end, current_variable)\n",
    "                    for m in range(begin_index, end_index+1):\n",
    "                        if 'record' in range_try[m]:\n",
    "                            range_try[m] = re.sub(r'^(CVS_|Non_CVS_)', '', range_try[m])\n",
    "                        else:\n",
    "                            range_try[m] = [range_perc, step_counter, stops]\n",
    "\n",
    "                    experiment = []\n",
    "\n",
    "                    experiment.append(cvs_try[i])\n",
    "                    experiment_begin = separate_actions_check['begins'][i]\n",
    "                    experiment_end = separate_actions_check['ends'][i]\n",
    "                    begin_index = i\n",
    "                    end_index = i\n",
    "                    current_variable = re.sub(r'^(CVS_explore_|Non_CVS_explore_)', '', cvs_try[i])\n",
    "            elif 'CVS_record' in cvs_try[i] or 'Non_CVS_record' in cvs_try[i]:\n",
    "                experiment.append(cvs_try[i])\n",
    "                experiment_end = separate_actions_check['ends'][i]\n",
    "                end_index = i\n",
    "            else:\n",
    "                step_counter = sum('record' in k for k in experiment)\n",
    "                range_perc, stops = ranger_stop(st_act_check, experiment_begin, experiment_end, current_variable)\n",
    "                for m in range(begin_index, end_index+1):\n",
    "                    if 'record' in range_try[m]:\n",
    "                        range_try[m] = re.sub(r'^(CVS_|Non_CVS_)', '', range_try[m])\n",
    "                    else:\n",
    "                        range_try[m] = [range_perc, step_counter, stops]\n",
    "                        \n",
    "                experiment = []\n",
    "                experiment_begin = None\n",
    "                experiment_end = None\n",
    "                current_variable = None\n",
    "                begin_index = None\n",
    "                end_index = None\n",
    "\n",
    "    if experiment != []:\n",
    "        step_counter = sum('record' in k for k in experiment)\n",
    "        range_perc, stops = ranger_stop(st_act_check, experiment_begin, experiment_end, current_variable)\n",
    "        for m in range(begin_index, end_index+1):\n",
    "            if 'record' in range_try[m]:\n",
    "                range_try[m] = re.sub(r'^(CVS_|Non_CVS_)', '', range_try[m])\n",
    "            else:\n",
    "                range_try[m] = [range_perc, step_counter, stops]\n",
    "\n",
    "    for i in range(len(cvs_try)):\n",
    "        if 'CVS_explore_solution' in cvs_try[i] or 'Non_CVS_explore_solution' in cvs_try[i]:\n",
    "            solution_timestamp = separate_actions_check['begins'][i]\n",
    "            for j in range(len(st_act_check['new_seq']['actions']['timestamp'])):\n",
    "                if solution_timestamp == st_act_check['new_seq']['actions']['timestamp'][j]:\n",
    "                    solution = st_act_check['new_seq']['state']['solution'][j+1]\n",
    "                    solutions.append(solution)\n",
    "        elif 'record' in cvs_try[i]:\n",
    "            range_try[i] = re.sub(r'^(CVS_|Non_CVS_)', '', range_try[i])\n",
    "\n",
    "    unique_solutions = set(solutions)\n",
    "    percentage_range_solutions = len(unique_solutions)/0.08\n",
    "    for i in range(len(cvs_try)):\n",
    "        if 'CVS_explore_solution' in cvs_try[i] or 'Non_CVS_explore_solution' in cvs_try[i]:\n",
    "            range_try[i] = [percentage_range_solutions, 0, 0]\n",
    "\n",
    "    return range_try\n",
    "                        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Insert back breaks and analysis_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def insert_breaks_and_table(separate_actions_check, breaks_and_table, cvs_try, optimal_try, range_try):    \n",
    "    new_labels = {'actions': [], 'begins': [], 'ends': [], 'CVS': [], 'Optimal': [], 'Range: percentage, steps, stops': []}\n",
    "        \n",
    "    # Iterate through both lists simultaneously\n",
    "    i = 0\n",
    "    j = 0\n",
    "    while i < len(separate_actions_check['begins']) and j < len(breaks_and_table['begins']):\n",
    "        # Compare the elements at the current positions\n",
    "        if separate_actions_check['begins'][i] < breaks_and_table['begins'][j]:\n",
    "            # Add the smaller number to the merged list\n",
    "            new_labels['actions'].append(separate_actions_check['actions'][i])\n",
    "            new_labels['begins'].append(separate_actions_check['begins'][i])\n",
    "            new_labels['ends'].append(separate_actions_check['ends'][i])\n",
    "            new_labels['CVS'].append(cvs_try[i])\n",
    "            new_labels['Optimal'].append(optimal_try[i])\n",
    "            new_labels['Range: percentage, steps, stops'].append(range_try[i])\n",
    "            i += 1\n",
    "        else:\n",
    "            new_labels['actions'].append(breaks_and_table['actions'][j])\n",
    "            new_labels['begins'].append(breaks_and_table['begins'][j])\n",
    "            new_labels['ends'].append(breaks_and_table['ends'][j])\n",
    "            new_labels['CVS'].append(breaks_and_table['actions'][j])\n",
    "            new_labels['Optimal'].append(breaks_and_table['actions'][j])\n",
    "            new_labels['Range: percentage, steps, stops'].append(breaks_and_table['actions'][j])\n",
    "            j += 1\n",
    "\n",
    "    # Add remaining elements from both lists (if any)\n",
    "    new_labels['actions'].extend(separate_actions_check['actions'][i:])\n",
    "    new_labels['begins'].extend(separate_actions_check['begins'][i:])\n",
    "    new_labels['ends'].extend(separate_actions_check['ends'][i:])\n",
    "    new_labels['CVS'].extend(cvs_try[i:])\n",
    "    new_labels['Optimal'].extend(optimal_try[i:])\n",
    "    new_labels['Range: percentage, steps, stops'].extend(range_try[i:])\n",
    "\n",
    "    new_labels['actions'].extend(breaks_and_table['actions'][j:])\n",
    "    new_labels['begins'].extend(breaks_and_table['begins'][j:])\n",
    "    new_labels['ends'].extend(breaks_and_table['ends'][j:])\n",
    "    new_labels['CVS'].extend(breaks_and_table['actions'][j:])\n",
    "    new_labels['Optimal'].extend(breaks_and_table['actions'][j:])\n",
    "    new_labels['Range: percentage, steps, stops'].extend(breaks_and_table['actions'][j:])\n",
    "\n",
    "    return new_labels\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labeling analysis actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_odd_occurrences(numbers):\n",
    "    counts = Counter(numbers)\n",
    "    odd_occurrences = [num for num, count in counts.items() if count % 2 != 0]\n",
    "    return odd_occurrences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def analysis_labeling(new_labels, sim_data_check, table_points, separate_actions_check):    \n",
    "    counter_plot = 0\n",
    "    analysis_experiment = []\n",
    "    analysis_timestamps = []\n",
    "    analysis_points = []\n",
    "\n",
    "    for i in range(len(separate_actions_check['actions'])):\n",
    "        if 'analysis_plot' in separate_actions_check['actions'][i]:\n",
    "            analysis_experiment.append(separate_actions_check['actions'][i])\n",
    "            analysis_timestamps.append(separate_actions_check['begins'][i])\n",
    "            counter_plot += 1\n",
    "        elif 'analysis_remove' in separate_actions_check['actions'][i]:\n",
    "            analysis_experiment.append(separate_actions_check['actions'][i])\n",
    "            analysis_timestamps.append(separate_actions_check['begins'][i])\n",
    "            counter_plot -= 1\n",
    "            \n",
    "            if counter_plot == 0:\n",
    "                for k in range(len(analysis_experiment)-1, -1, -1):\n",
    "                    if 'analysis_plot' in analysis_experiment[k]:\n",
    "                        stop_index = k\n",
    "                        break\n",
    "\n",
    "                # forming the analysis_points - till the last analysis_plot\n",
    "                for j in range(stop_index + 1):\n",
    "                    for m in range(len(sim_data_check['logs'])):\n",
    "                        if analysis_timestamps[j] == sim_data_check['logs'][m]['timestamp']:\n",
    "                            analysis_points.append(sim_data_check['logs'][m]['table_point'])\n",
    "                            break\n",
    "                result_points = find_odd_occurrences(analysis_points)\n",
    "\n",
    "                # finding the concentration, width, wavelength and solution for each result point\n",
    "                concentration = []\n",
    "                width = []\n",
    "                wavelength = []\n",
    "                solution = []\n",
    "\n",
    "                for j in range(len(analysis_points)):\n",
    "                    for m in range(1, len(table_points)+1):\n",
    "                        if analysis_points[j] == m and m in result_points:\n",
    "                            concentration.append(table_points[m]['concentration'])\n",
    "                            width.append(table_points[m]['width'])\n",
    "                            wavelength.append(table_points[m]['wavelength'])\n",
    "                            solution.append(table_points[m]['solution'])\n",
    "                            break\n",
    "                \n",
    "                # finding the cvs_label\n",
    "                if len(concentration) == 1:\n",
    "                    cvs_label = 'Non_CVS_analysis'\n",
    "                elif all(x == concentration[0] for x in concentration) and all(x == width[0] for x in width) and all(x == wavelength[0] for x in wavelength) and all(x == solution[0] for x in solution):\n",
    "                    cvs_label = 'repeat'\n",
    "                else:\n",
    "                    if all(x == concentration[0] for x in concentration) and all(x == width[0] for x in width) and all(x == wavelength[0] for x in wavelength):\n",
    "                        cvs_label = 'CVS_analysis_solution'\n",
    "                    elif all(x == concentration[0] for x in concentration) and all(x == width[0] for x in width) and all(x == solution[0] for x in solution):\n",
    "                        cvs_label = 'CVS_analysis_wavelength'\n",
    "                    elif all(x == concentration[0] for x in concentration) and all(x == wavelength[0] for x in wavelength) and all(x == solution[0] for x in solution):\n",
    "                        cvs_label = 'CVS_analysis_width'\n",
    "                    elif all(x == width[0] for x in width) and all(x == wavelength[0] for x in wavelength) and all(x == solution[0] for x in solution):\n",
    "                        cvs_label = 'CVS_analysis_concentration'\n",
    "                    else:\n",
    "                        cvs_label = 'Non_CVS_analysis'\n",
    "\n",
    "                # finding the optimal_label\n",
    "                if cvs_label == 'repeat':\n",
    "                    optimal_label = 'Non_Optimal_analysis'\n",
    "\n",
    "                elif cvs_label == 'CVS_analysis_width':\n",
    "                    if solution[0] == 'drink Mix (red)' or solution[0] == 'Cobalt nitrate (red)' or solution[0] == 'Cobalt chloride (red)':\n",
    "                        if wavelength[0] not in range(620, 780) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_width'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_width'\n",
    "                    elif solution[0] == 'Copper sulfate (blue)':\n",
    "                        if wavelength[0] not in range(450, 495) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_width'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_width'\n",
    "                    elif solution[0] == 'Nickel chloride (green)':\n",
    "                        if wavelength[0] not in range(495, 570) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_width'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_width'\n",
    "                    elif solution[0] == 'Potassium chromate (yellow)':\n",
    "                        if wavelength[0] not in range(570, 590) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_width'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_width'\n",
    "                    elif solution[0] == 'Potassium dichromate (orange)':\n",
    "                        if wavelength[0] not in range(590, 620) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_width'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_width'\n",
    "                    elif solution[0] == 'Potassium permanganate (purple)':\n",
    "                        if wavelength[0] not in range(620, 700) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_width'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_width'\n",
    "\n",
    "                elif cvs_label == 'CVS_analysis_concentration':\n",
    "                    if solution[0] == 'drink Mix (red)' or solution[0] == 'Cobalt nitrate (red)' or solution[0] == 'Cobalt chloride (red)':\n",
    "                        if wavelength[0] not in range(620, 780) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_concentration'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "                    elif solution[0] == 'Copper sulfate (blue)':\n",
    "                        if wavelength[0] not in range(450, 495) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_concentration'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "                    elif solution[0] == 'Nickel chloride (green)':\n",
    "                        if wavelength[0] not in range(495, 570) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_concentration'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "                    elif solution[0] == 'Potassium chromate (yellow)':\n",
    "                        if wavelength[0] not in range(570, 590) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_concentration'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "                    elif solution[0] == 'Potassium dichromate (orange)':\n",
    "                        if wavelength[0] not in range(590, 620) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_concentration'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "                    elif solution[0] == 'Potassium permanganate (purple)':\n",
    "                        if wavelength[0] not in range(620, 700) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                            optimal_label = 'Optimal_analysis_concentration'\n",
    "                        else:\n",
    "                            optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "\n",
    "                elif cvs_label == 'CVS_analysis_wavelength':\n",
    "                    optimal_label = 'Non_Optimal_analysis_wavelength'\n",
    "\n",
    "                elif len(concentration) == 1:\n",
    "                    optimal_label = 'Non_Optimal_analysis'\n",
    "\n",
    "                else:\n",
    "                    optimal_label = 'analysis'\n",
    "\n",
    "                # finding the range_label\n",
    "                if cvs_label == 'repeat':\n",
    "                    range_label = 0\n",
    "                \n",
    "                elif cvs_label == 'CVS_analysis_width':\n",
    "                    max_width = max(width)\n",
    "                    min_width = min(width)\n",
    "                    range_label = round((max_width - min_width)/1.5 * 100, 2)\n",
    "\n",
    "                elif cvs_label == 'CVS_analysis_concentration':\n",
    "                    concentration_division = {\n",
    "                        'drink Mix (red)': 0.4,\n",
    "                        'Cobalt nitrate (red)': 0.4,\n",
    "                        'Cobalt chloride (red)': 0.25,\n",
    "                        'Copper sulfate (blue)': 0.2,\n",
    "                        'Nickel chloride (green)': 0.35,\n",
    "                        'Potassium chromate (yellow)': 0.0004,\n",
    "                        'Potassium dichromate (orange)': 0.0005,\n",
    "                        'Potassium permanganate (purple)': 0.0008\n",
    "                    }\n",
    "                    max_concentration = max(concentration)\n",
    "                    min_concentration = min(concentration)\n",
    "                    range_label = round((max_concentration - min_concentration)/concentration_division.get(solution[0]) * 100, 2)\n",
    "\n",
    "                elif cvs_label == 'CVS_analysis_wavelength':\n",
    "                    max_wavelength = max(wavelength)\n",
    "                    min_wavelength = min(wavelength)\n",
    "                    range_label = round((max_wavelength - min_wavelength)/400 * 100, 2)\n",
    "\n",
    "                elif cvs_label == 'CVS_analysis_solution':\n",
    "                    range_label = len(set(solution))/0.08\n",
    "\n",
    "                elif len(concentration) == 1:\n",
    "                    range_label = 0\n",
    "\n",
    "                else:\n",
    "                    if 'analysis_plot_width' in analysis_experiment:\n",
    "                        max_width = max(width)\n",
    "                        min_width = min(width)\n",
    "                        range_label = round((max_width - min_width)/1.5 * 100, 2)\n",
    "\n",
    "                    elif 'analysis_plot_concentration' in analysis_experiment:\n",
    "                        if all(x == solution[0] for x in solution):\n",
    "                            concentration_division = {\n",
    "                                'drink Mix (red)': 0.4,\n",
    "                                'Cobalt nitrate (red)': 0.4,\n",
    "                                'Cobalt chloride (red)': 0.25,\n",
    "                                'Copper sulfate (blue)': 0.2,\n",
    "                                'Nickel chloride (green)': 0.35,\n",
    "                                'Potassium chromate (yellow)': 0.0004,\n",
    "                                'Potassium dichromate (orange)': 0.0005,\n",
    "                                'Potassium permanganate (purple)': 0.0008\n",
    "                            }\n",
    "                            max_concentration = max(concentration)\n",
    "                            min_concentration = min(concentration)\n",
    "                            range_label = round((max_concentration - min_concentration)/concentration_division.get(solution[0]) * 100, 2)\n",
    "                        else:\n",
    "                            range_label = 'analysis'\n",
    "\n",
    "                    else:\n",
    "                        range_label = 'analysis'\n",
    "\n",
    "\n",
    "                # assigning the labels\n",
    "                for j in range(len(analysis_experiment)):\n",
    "                    for m in range(len(new_labels['begins'])):\n",
    "                        if analysis_timestamps[j] == new_labels['begins'][m]:\n",
    "                            if 'analysis_plot' in analysis_experiment[j]:\n",
    "                                if analysis_points[j] in result_points:\n",
    "                                    new_labels['CVS'][m] = cvs_label\n",
    "                                    new_labels['Optimal'][m] = optimal_label\n",
    "                                    new_labels['Range: percentage, steps, stops'][m] = [range_label, len(result_points)]\n",
    "                                else:\n",
    "                                    new_labels['CVS'][m] = 'other'\n",
    "                                    new_labels['Optimal'][m] = 'other'\n",
    "                                    new_labels['Range: percentage, steps, stops'][m] = 'other'\n",
    "                            else:\n",
    "                                new_labels['CVS'][m] = 'other' \n",
    "                                new_labels['Optimal'][m] = 'other'\n",
    "                                new_labels['Range: percentage, steps, stops'][m] = 'other'              \n",
    "                            break\n",
    "                \n",
    "                analysis_experiment = []\n",
    "                analysis_timestamps = []\n",
    "                analysis_points = []\n",
    "\n",
    "    # for the last analysis_experiment\n",
    "    if analysis_experiment != []:\n",
    "        for j in range(len(analysis_experiment)):\n",
    "            for m in range(len(sim_data_check['logs'])):\n",
    "                if analysis_timestamps[j] == sim_data_check['logs'][m]['timestamp']:\n",
    "                    analysis_points.append(sim_data_check['logs'][m]['table_point'])\n",
    "                    break\n",
    "        result_points = find_odd_occurrences(analysis_points)\n",
    "\n",
    "        concentration = []\n",
    "        width = []\n",
    "        wavelength = []\n",
    "        solution = []\n",
    "\n",
    "        for j in range(len(analysis_points)):\n",
    "            for m in range(1, len(table_points)+1):\n",
    "                if analysis_points[j] == m and m in result_points:\n",
    "                    concentration.append(table_points[m]['concentration'])\n",
    "                    width.append(table_points[m]['width'])\n",
    "                    wavelength.append(table_points[m]['wavelength'])\n",
    "                    solution.append(table_points[m]['solution'])\n",
    "                    break\n",
    "        \n",
    "        # finding the cvs_label\n",
    "        if len(concentration) == 1:\n",
    "            cvs_label = 'Non_CVS_analysis'\n",
    "        elif all(x == concentration[0] for x in concentration) and all(x == width[0] for x in width) and all(x == wavelength[0] for x in wavelength) and all(x == solution[0] for x in solution):\n",
    "            cvs_label = 'repeat'\n",
    "        else:\n",
    "            if all(x == concentration[0] for x in concentration) and all(x == width[0] for x in width) and all(x == wavelength[0] for x in wavelength):\n",
    "                cvs_label = 'CVS_analysis_solution'\n",
    "            elif all(x == concentration[0] for x in concentration) and all(x == width[0] for x in width) and all(x == solution[0] for x in solution):\n",
    "                cvs_label = 'CVS_analysis_wavelength'\n",
    "            elif all(x == concentration[0] for x in concentration) and all(x == wavelength[0] for x in wavelength) and all(x == solution[0] for x in solution):\n",
    "                cvs_label = 'CVS_analysis_width'\n",
    "            elif all(x == width[0] for x in width) and all(x == wavelength[0] for x in wavelength) and all(x == solution[0] for x in solution):\n",
    "                cvs_label = 'CVS_analysis_concentration'\n",
    "            else:\n",
    "                cvs_label = 'Non_CVS_analysis'\n",
    "\n",
    "        # finding the optimal_label\n",
    "        if cvs_label == 'repeat':\n",
    "            optimal_label = 'Non_Optimal_analysis'\n",
    "\n",
    "        elif cvs_label == 'CVS_analysis_width':\n",
    "            if solution[0] == 'drink Mix (red)' or solution[0] == 'Cobalt nitrate (red)' or solution[0] == 'Cobalt chloride (red)':\n",
    "                if wavelength[0] not in range(620, 780) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_width'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_width'\n",
    "            elif solution[0] == 'Copper sulfate (blue)':\n",
    "                if wavelength[0] not in range(450, 495) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_width'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_width'\n",
    "            elif solution[0] == 'Nickel chloride (green)':\n",
    "                if wavelength[0] not in range(495, 570) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_width'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_width'\n",
    "            elif solution[0] == 'Potassium chromate (yellow)':\n",
    "                if wavelength[0] not in range(570, 590) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_width'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_width'\n",
    "            elif solution[0] == 'Potassium dichromate (orange)':\n",
    "                if wavelength[0] not in range(590, 620) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_width'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_width'\n",
    "            elif solution[0] == 'Potassium permanganate (purple)':\n",
    "                if wavelength[0] not in range(620, 700) and concentration[0] != 0 and 'analysis_plot_width' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_width'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_width'\n",
    "\n",
    "        elif cvs_label == 'CVS_analysis_concentration':\n",
    "            if solution[0] == 'drink Mix (red)' or solution[0] == 'Cobalt nitrate (red)' or solution[0] == 'Cobalt chloride (red)':\n",
    "                if wavelength[0] not in range(620, 780) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_concentration'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "            elif solution[0] == 'Copper sulfate (blue)':\n",
    "                if wavelength[0] not in range(450, 495) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_concentration'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "            elif solution[0] == 'Nickel chloride (green)':\n",
    "                if wavelength[0] not in range(495, 570) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_concentration'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "            elif solution[0] == 'Potassium chromate (yellow)':\n",
    "                if wavelength[0] not in range(570, 590) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_concentration'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "            elif solution[0] == 'Potassium dichromate (orange)':\n",
    "                if wavelength[0] not in range(590, 620) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_concentration'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "            elif solution[0] == 'Potassium permanganate (purple)':\n",
    "                if wavelength[0] not in range(620, 700) and 'analysis_plot_concentration' in analysis_experiment:\n",
    "                    optimal_label = 'Optimal_analysis_concentration'\n",
    "                else:\n",
    "                    optimal_label = 'Non_Optimal_analysis_concentration'\n",
    "\n",
    "        elif cvs_label == 'CVS_analysis_wavelength':\n",
    "            optimal_label = 'Non_Optimal_analysis_wavelength'\n",
    "\n",
    "        elif len(concentration) == 1:\n",
    "            optimal_label = 'Non_Optimal_analysis'\n",
    "\n",
    "        else:\n",
    "            optimal_label = 'analysis'\n",
    "\n",
    "        # finding the range_label\n",
    "        if cvs_label == 'repeat':\n",
    "            range_label = 0\n",
    "        \n",
    "        elif cvs_label == 'CVS_analysis_width':\n",
    "            max_width = max(width)\n",
    "            min_width = min(width)\n",
    "            range_label = round((max_width - min_width)/1.5 * 100, 2)\n",
    "\n",
    "        elif cvs_label == 'CVS_analysis_concentration':\n",
    "            concentration_division = {\n",
    "                'drink Mix (red)': 0.4,\n",
    "                'Cobalt nitrate (red)': 0.4,\n",
    "                'Cobalt chloride (red)': 0.25,\n",
    "                'Copper sulfate (blue)': 0.2,\n",
    "                'Nickel chloride (green)': 0.35,\n",
    "                'Potassium chromate (yellow)': 0.0004,\n",
    "                'Potassium dichromate (orange)': 0.0005,\n",
    "                'Potassium permanganate (purple)': 0.0008\n",
    "            }\n",
    "            max_concentration = max(concentration)\n",
    "            min_concentration = min(concentration)\n",
    "            range_label = round((max_concentration - min_concentration)/concentration_division.get(solution[0]) * 100, 2)\n",
    "\n",
    "        elif cvs_label == 'CVS_analysis_wavelength':\n",
    "            max_wavelength = max(wavelength)\n",
    "            min_wavelength = min(wavelength)\n",
    "            range_label = round((max_wavelength - min_wavelength)/400 * 100, 2)\n",
    "\n",
    "        elif cvs_label == 'CVS_analysis_solution':\n",
    "            range_label = len(set(solution))/0.08\n",
    "\n",
    "        elif len(concentration) == 1:\n",
    "            range_label = 0\n",
    "\n",
    "        else:\n",
    "            if 'analysis_plot_width' in analysis_experiment:\n",
    "                max_width = max(width)\n",
    "                min_width = min(width)\n",
    "                range_label = round((max_width - min_width)/1.5 * 100, 2)\n",
    "\n",
    "            elif 'analysis_plot_concentration' in analysis_experiment:\n",
    "                if all(x == solution[0] for x in solution):\n",
    "                    concentration_division = {\n",
    "                        'drink Mix (red)': 0.4,\n",
    "                        'Cobalt nitrate (red)': 0.4,\n",
    "                        'Cobalt chloride (red)': 0.25,\n",
    "                        'Copper sulfate (blue)': 0.2,\n",
    "                        'Nickel chloride (green)': 0.35,\n",
    "                        'Potassium chromate (yellow)': 0.0004,\n",
    "                        'Potassium dichromate (orange)': 0.0005,\n",
    "                        'Potassium permanganate (purple)': 0.0008\n",
    "                    }\n",
    "                    max_concentration = max(concentration)\n",
    "                    min_concentration = min(concentration)\n",
    "                    range_label = round((max_concentration - min_concentration)/concentration_division.get(solution[0]) * 100, 2)\n",
    "                else:\n",
    "                    range_label = 'analysis'\n",
    "\n",
    "            else:\n",
    "                range_label = 'analysis'\n",
    "\n",
    "        # assigning the labels\n",
    "        for j in range(len(analysis_experiment)):\n",
    "            for m in range(len(new_labels['begins'])):\n",
    "                if analysis_timestamps[j] == new_labels['begins'][m]:\n",
    "                    if 'analysis_plot' in analysis_experiment[j]:\n",
    "                        if analysis_points[j] in result_points:\n",
    "                            new_labels['CVS'][m] = cvs_label\n",
    "                            new_labels['Optimal'][m] = optimal_label\n",
    "                            new_labels['Range: percentage, steps, stops'][m] = [range_label, len(result_points)]\n",
    "                        else:\n",
    "                            new_labels['CVS'][m] = 'other'\n",
    "                            new_labels['Optimal'][m] = 'other'\n",
    "                            new_labels['Range: percentage, steps, stops'][m] = 'other'\n",
    "                    else:\n",
    "                        new_labels['CVS'][m] = 'other' \n",
    "                        new_labels['Optimal'][m] = 'other'\n",
    "                        new_labels['Range: percentage, steps, stops'][m] = 'other'               \n",
    "                    break\n",
    "    return new_labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define total function for new labeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def new_labeling(st_act_check, sim_data_check):\n",
    "\n",
    "    table_points = {}\n",
    "    count_points = 1\n",
    "    for i in range(len(st_act_check['new_seq']['actions']['action'])):\n",
    "        if 'record' in st_act_check['new_seq']['actions']['action'][i]:\n",
    "            table_points[count_points] = {'timestamp': st_act_check['new_seq']['actions']['timestamp'][i],\n",
    "                                            'width': st_act_check['new_seq']['state']['width'][i],\n",
    "                                            'concentration': st_act_check['new_seq']['state']['concentration'][i],\n",
    "                                            'wavelength': st_act_check['new_seq']['state']['wavelength'][i],\n",
    "                                            'solution': st_act_check['new_seq']['state']['solution'][i],\n",
    "                                            'absorbance': st_act_check['new_seq']['state']['absorbance'][i],\n",
    "                                            }\n",
    "\n",
    "            count_points += 1\n",
    "\n",
    "    separate_explore_check = variables_sequencer_v1(st_act_check, sim_data_check, threshold = 3000)\n",
    "    \n",
    "    separate_actions_check = {'actions': [], 'begins': [], 'ends': []}\n",
    "    for action, begin, end in separate_explore_check['var_seq_v1']:\n",
    "            if action not in ['break', 'analysis_table']:\n",
    "                separate_actions_check['actions'].append(action)\n",
    "                separate_actions_check['begins'].append(begin)\n",
    "                separate_actions_check['ends'].append(end)\n",
    "\n",
    "    cvs_try = cvs_labeling(separate_actions_check, st_act_check)\n",
    "    optimal_try = optimal_labeling(cvs_try, separate_actions_check, st_act_check)\n",
    "    range_try = range_labeling_stop(cvs_try, separate_actions_check, st_act_check)\n",
    "\n",
    "    breaks_and_table = {'actions': [], 'begins': [], 'ends': []}\n",
    "    for action, begin, end in separate_explore_check['var_seq_v1']:\n",
    "        if action == 'break' or action == 'analysis_table':\n",
    "            breaks_and_table['actions'].append(action)\n",
    "            breaks_and_table['begins'].append(begin)\n",
    "            breaks_and_table['ends'].append(end)\n",
    "\n",
    "\n",
    "    new_labels = insert_breaks_and_table(separate_actions_check, breaks_and_table, cvs_try, optimal_try, range_try)\n",
    "    new_labels_final = analysis_labeling(new_labels, sim_data_check, table_points, separate_actions_check)\n",
    "    final_dict = {'group': st_act_check['group'], 'subgroup': st_act_check['subgroup'], 'session_code': st_act_check['session_code'], 'task': st_act_check['task'], 'single_exp': new_labels_final}\n",
    "\n",
    "    return final_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply to all files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_directory1 = '///' # Directory with the Sequences\n",
    "base_directory2 = '///' # Directory with the Parsed files\n",
    "\n",
    "# Iterate over all files in base_directory1\n",
    "for file1 in Path(base_directory1).rglob('*.pkl'):\n",
    "    # Load the 'session_code' and 'group'/'subgroup' from the first file\n",
    "    with open(file1, 'rb') as fp1:\n",
    "        state_action = pickle.load(fp1)\n",
    "        session_code = state_action.get('session_code')\n",
    "    \n",
    "    # Check if 'session_code' exists in the first file\n",
    "    if session_code:\n",
    "        # Construct the corresponding file paths in base_directory2\n",
    "        file2 = next(Path(base_directory2).rglob(f'**/*{session_code}*.pkl'), None)\n",
    "        \n",
    "        # Check if corresponding file was found in base_directory2\n",
    "        if file2:\n",
    "            # Load data from the two files\n",
    "            with open(file1, 'rb') as fp1, open(file2, 'rb') as fp2:\n",
    "                st_act_check = pickle.load(fp1)\n",
    "                sim_data_check = pickle.load(fp2)\n",
    "\n",
    "                session_code = st_act_check['session_code']\n",
    "                print(session_code)\n",
    "        \n",
    "\n",
    "                path = \"///.pkl\".format(session_code)\n",
    "                with open(path, 'wb') as fp:\n",
    "                    pickle.dump(new_labeling(st_act_check, sim_data_check), fp)"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}