splitting-by-models.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_models(start, end, patient_id):\n",
    "    models = []\n",
    "    for start_ in np.arange(start, end, 30):\n",
    "        for end_ in np.arange(start_ + 100, end + 1, 70):\n",
    "            for reg_method in [2]:\n",
    "                models.append(estimate_T(start_, end_, patient_id, reg_method))\n",
    "    return models\n",
    "\n",
    "Period = namedtuple('Period', ['start', 'end'])\n",
    "def all_periods(start, end):\n",
    "    periods = []\n",
    "    for start_ in np.arange(start, end, 100):\n",
    "        end_ = start_ + 100\n",
    "        period = Period(start_, end_)\n",
    "        periods.append(period)\n",
    "    return periods\n",
    "\n",
    "def models_periods_table(start, end, patient_id):\n",
    "    \n",
    "    if os.path.exists('pickles/table'+str(patient_id)+'-'+str(start)+'-'+str(end)) == True:\n",
    "        table = pickle.load(open('pickles/table'+str(patient_id)+'-'+str(start)+'-'+str(end), 'rb'))\n",
    "        models = pickle.load(open('pickles/models'+str(patient_id)+'-'+str(start)+'-'+str(end), 'rb'))\n",
    "        periods = pickle.load(open('pickles/periods'+str(patient_id)+'-'+str(start)+'-'+str(end), 'rb'))\n",
    "        return table, models, periods\n",
    "    \n",
    "    models = all_models(start, end, patient_id)\n",
    "    periods = all_periods(start, end)\n",
    "\n",
    "    table = np.empty((len(periods),len(models)), dtype=object)\n",
    "    print(table.shape)\n",
    "\n",
    "    for i in range(len(models)):\n",
    "        for j in range(len(periods)):\n",
    "            prediction = test_T(models[i], periods[j].start, periods[j].end, patient_id)\n",
    "            table[j][i] = prediction.white_noise_rank\n",
    "            \n",
    "    with open('pickles/table'+str(patient_id)+'-'+str(start)+'-'+str(end), 'wb') as table_file:\n",
    "        pickle.dump(table, table_file)\n",
    "    with open('pickles/models'+str(patient_id)+\"-\"+str(start)+\"-\"+str(end), 'wb') as models_file:\n",
    "        pickle.dump(models, models_file)\n",
    "    with open('pickles/periods'+str(patient_id)+\"-\"+str(start)+\"-\"+str(end), 'wb') as periods_file:\n",
    "        pickle.dump(periods, periods_file)\n",
    "        \n",
    "    return table, models, periods\n",
    "\n",
    "def translate_table(table, models, periods, ac_limit, mean_limit):\n",
    "    clean_table = np.empty((len(periods),len(models)), dtype=object)\n",
    "    for i in range(len(models)):\n",
    "        for j in range(len(periods)):\n",
    "            white_noise_rank = table[j][i]\n",
    "            \n",
    "            rank = 0\n",
    "            signals = [0,1,3] #hr, bp, rr\n",
    "            errors_sum = 0\n",
    "            for signal in signals:\n",
    "                if (white_noise_rank[signal].mean <= mean_limit and white_noise_rank[signal].alpha_ac >= ac_limit) or white_noise_rank[signal].mean <= 0.5:\n",
    "                    rank = rank + 1\n",
    "                errors_sum = errors_sum + white_noise_rank[signal].mean\n",
    "            if rank == len(signals):\n",
    "                clean_table[j][i] = 1 - np.minimum(1,np.round((errors_sum/len(signals))/100, 5))\n",
    "            else:\n",
    "                clean_table[j][i] = 0\n",
    "    return clean_table\n",
    "\n",
    "\n",
    "def clean_table(table, models, periods):\n",
    "    if len(periods) == 1:\n",
    "        return table\n",
    "    clean_table = np.empty((len(periods),len(models)), dtype=object)\n",
    "    for i in range(len(models)):\n",
    "        for j in range(len(periods)):\n",
    "            clean_table[j][i] = table[j][i]\n",
    "            if table[j][i] > 0:\n",
    "                if (j == 0 and table[1][i] == 0) or (j == (len(periods) - 1) and table[len(periods) - 2][i] == 0) or ((j!=0) and (j!=(len(periods) - 1)) and (table[j-1][i] == 0) and (table[j+1][i]==0)):\n",
    "                    clean_table[j][i] = 0\n",
    "    return clean_table\n",
    "\n",
    "\n",
    "def popular_model(table, models, periods):\n",
    "    Period = namedtuple('Period', ['start', 'end'])\n",
    "    models_popularity = np.zeros(len(models))\n",
    "    model_periods = []\n",
    "    for i in range(len(models)):\n",
    "        pre_fit = 0\n",
    "        for j in range(len(periods)):\n",
    "            if pre_fit == 1 and table[j][i] > 0:\n",
    "                models_popularity[i] = models_popularity[i] + 1\n",
    "            if table[j][i] > 0:\n",
    "                models_popularity[i] = models_popularity[i] + table[j][i]\n",
    "                pre_fit = 1\n",
    "            else:\n",
    "                pre_fit = 0\n",
    "\n",
    "    print(\"models_popularity\", models_popularity)\n",
    "    popular_index = np.argmax(models_popularity)\n",
    "    print(\"popular_index\", popular_index)\n",
    "    to_delete = []\n",
    "    for i in range(len(periods)):\n",
    "        if table[i][popular_index] > 0:\n",
    "            if len(model_periods) == 0 or model_periods[-1].end != periods[i].start:\n",
    "                model_periods.append(periods[i])\n",
    "            else:\n",
    "                last_period_start = model_periods[-1].start\n",
    "                model_periods.pop(-1)\n",
    "                model_periods.append(Period(last_period_start, periods[i].end))\n",
    "            to_delete.append(i)\n",
    "    for i in reversed(to_delete):\n",
    "        table = np.delete(table, i, axis=0)\n",
    "        periods.pop(i)\n",
    "    return table, periods, models[popular_index], model_periods\n",
    "\n",
    "\n",
    "\n",
    "Model_Periods = namedtuple('Model_Periods', ['model', 'model_periods'])\n",
    "def split_to_models(start, end, patient_id):\n",
    "    \n",
    "    best_rank = -np.inf\n",
    "    best_results = None\n",
    "    ac_limit_list = [0.1, 0.05, 0.03]\n",
    "    mean_limit_list = [1, 1.9, 2.8]\n",
    "    for ac_limit in ac_limit_list:\n",
    "        for mean_limit in mean_limit_list:\n",
    "            result_rank = 0.4*(ac_limit-min(ac_limit_list))/(max(ac_limit_list)-min(ac_limit_list)) + 1 - (mean_limit-min(mean_limit_list))/(max(mean_limit_list)-min(mean_limit_list))\n",
    "            print(\"ac_limit, mean_limit = \", ac_limit, mean_limit)\n",
    "            table, models, periods = models_periods_table(start, end, patient_id)\n",
    "            table = translate_table(table, models, periods, ac_limit, mean_limit)\n",
    "            table = clean_table(table, models, periods)\n",
    "\n",
    "            results = []\n",
    "            for i in range(3):\n",
    "                table, periods, popular_model_, model_periods = popular_model(table, models, periods)\n",
    "                table = clean_table(table, models, periods)\n",
    "                if len(model_periods) == 0:\n",
    "                    break;\n",
    "                else:\n",
    "                    results.append(Model_Periods(popular_model_, model_periods))\n",
    "            \n",
    "            #result_rank = 0.01*result_rank + ((end-start)-len(periods)*100)/len(results)\n",
    "            result_rank = 0.1*result_rank + 1-len(results)/3\n",
    "            result_rank = 0.25*result_rank + ((end-start)-len(periods)*100)/(end-start)\n",
    "            \n",
    "            if result_rank > best_rank:\n",
    "                best_rank = result_rank\n",
    "                best_results = results\n",
    "    \n",
    "    prediction_results = []\n",
    "    for result in best_results:\n",
    "        prediction_results_one_model = []\n",
    "        for period in result.model_periods:\n",
    "            prediction = test_T(result.model, period.start, period.end, patient_id)\n",
    "            prediction_results_one_model.append(prediction)\n",
    "            #print_prediction_results(prediction)\n",
    "        prediction_results.append(prediction_results_one_model)\n",
    "    print_prediction_results(prediction_results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}