data_preprocess.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 781,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.io\n",
    "from scipy import stats\n",
    "from collections import Counter\n",
    "import numpy as np\n",
    "from scipy.signal import find_peaks\n",
    "from interval import interval\n",
    "import os\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing steps\n",
    "\n",
    "![](./files/preprocessing1.png)\n",
    "![](./files/preprocessing2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 782,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = scipy.io.loadmat('./physionet_dataset_processed/1001m.mat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a) FHR spike removal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 783,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fhr_spike_removal(mat):\n",
    "    # Get FHR signal\n",
    "    fhr = mat['val'][0]\n",
    "\n",
    "    i = 0\n",
    "    while fhr[-1] == 0:\n",
    "        i = i + 1\n",
    "        fhr = np.delete(fhr,-1)\n",
    "    i = 0\n",
    "    while fhr[0] == 0:\n",
    "        i = i + 1\n",
    "        fhr = np.delete(fhr,0)\n",
    "\n",
    "    spike = []\n",
    "    for x in range(len(fhr)-1):\n",
    "        if abs(fhr[x+1]-fhr[x]) > 25*100:\n",
    "            spike.append(x)\n",
    "\n",
    "    stable = []\n",
    "    for x in range(len(fhr)-4):\n",
    "        if abs(fhr[x+1]-fhr[x]) < 10*100 and abs(fhr[x+2]-fhr[x+1]) < 10*100 and abs(fhr[x+3]-fhr[x+2]) < 10*100 and abs(fhr[x+4]-fhr[x+3]) < 10*100 and fhr[x] != 0:\n",
    "            stable.append(x)\n",
    "\n",
    "    n = float('-inf')\n",
    "    for s in spike:\n",
    "        if s <= n :\n",
    "            continue\n",
    "        l = [i for i in stable if i > s]\n",
    "        if len(l) > 0:\n",
    "            n = l[0]\n",
    "        else:\n",
    "            break\n",
    "        for t in range(s+1,n,1):\n",
    "            fhr[t] = fhr[t-1] + (fhr[n]-fhr[s])/(n-s)\n",
    "    \n",
    "    return fhr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 784,
   "metadata": {},
   "outputs": [],
   "source": [
    "fhr = fhr_spike_removal(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Filtering of uterine contraction signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 785,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_uterine_contractions(mat):\n",
    "    # Get UC signal\n",
    "    uc = mat['val'][1]\n",
    "\n",
    "    i = 0\n",
    "    window_size = 17\n",
    "    moving_averages = []\n",
    "    while i < len(uc) - window_size + 1:\n",
    "        this_window = uc[i : i + window_size]\n",
    "        window_average = sum(this_window) / window_size\n",
    "        moving_averages.append(window_average)\n",
    "        i += 1\n",
    "\n",
    "    return moving_averages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 786,
   "metadata": {},
   "outputs": [],
   "source": [
    "uc = filter_uterine_contractions(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Detection of uterine contractions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 787,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uterine_contraction_detection(uc):\n",
    "    #Detection of contractions\n",
    "    nuc = [50 * round(x/50) for x in uc]\n",
    "    mode,_ = stats.mode([x for x in nuc if x > 900])\n",
    "    mode = mode[0]\n",
    "    contraction_intervals = []\n",
    "    i = 0\n",
    "    contraction_total_time = 0\n",
    "    while i+20*4 < len(nuc):\n",
    "        shifted_fhr = [x-mode for x in nuc[i:i+20*4]]\n",
    "        if all([x>0 for x in shifted_fhr]) == True:\n",
    "            max_shift = max(shifted_fhr)\n",
    "            j = i+20*4\n",
    "            while  j<len(nuc) and nuc[j]-mode>0:\n",
    "                if nuc[j]-mode>max_shift:\n",
    "                    max_shift = nuc[j]-mode\n",
    "                j = j + 1\n",
    "            if max_shift > 3*100:\n",
    "                contraction_intervals.append([i,j])\n",
    "                contraction_total_time = contraction_total_time + j - i\n",
    "            i = j\n",
    "        else:\n",
    "            i = i + 1\n",
    "    return contraction_intervals, contraction_total_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 788,
   "metadata": {},
   "outputs": [],
   "source": [
    "contraction_intervals, contraction_total_time = uterine_contraction_detection(uc)\n",
    "contraction_number_per_second = 4*len(contraction_intervals)/len(uc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Evaluation of abnormal and mean short-term variability(STV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 789,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stv_calculation(fhr):\n",
    "    #stv calculation\n",
    "    stv = []\n",
    "    #for x in range(len(fhr)-1):\n",
    "    #    stv.append(abs(fhr[x] - fhr[x+1]))\n",
    "    for x in range(1,len(fhr)-1):\n",
    "        stv.append(abs(fhr[x-1] - fhr[x+1]))\n",
    "\n",
    "    #mean\n",
    "    stv_mean = sum(stv)/len(stv)\n",
    "    stv_mean = stv_mean/100\n",
    "    #abnormal percentage\n",
    "    stv_abnormal = [x for x in stv if x < 100]\n",
    "    stv_abn_per = 100*len(stv_abnormal)/len(stv)\n",
    "\n",
    "    return stv_mean, stv_abn_per"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 790,
   "metadata": {},
   "outputs": [],
   "source": [
    "stv_mean, stv_abn_per = stv_calculation(fhr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e) Filtering of fhr signals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 791,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_fhr_signals(fhr):\n",
    "    i = 0\n",
    "    window_size = 5\n",
    "    moving_averages = []\n",
    "    while i < len(fhr) - window_size + 1:\n",
    "        this_window = fhr[i : i + window_size]\n",
    "        window_average = sum(this_window) / window_size\n",
    "        moving_averages.append(window_average)\n",
    "        i += 1\n",
    "\n",
    "    return moving_averages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 792,
   "metadata": {},
   "outputs": [],
   "source": [
    "fhr = filter_fhr_signals(fhr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f) Quantification of fetal movements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 793,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Skip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "g) Estimation of the FHR baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 794,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fhr_baseline_estimation(fhr):\n",
    "    def find_baseline(f,h,BL,imax):\n",
    "        stv_abn_fr = stv_abn_per/100\n",
    "        if BL >=  110:\n",
    "            if BL > 152: \n",
    "                for i in range(1,imax):\n",
    "                    if f[i] >= 110 and f[i] < BL and h[i] > 1.6*stv_abn_fr*h[0]:\n",
    "                        if f[i] < BL:\n",
    "                            BL = f[i]\n",
    "                return BL \n",
    "            else:\n",
    "                if stv_abn_per < 20:\n",
    "                    F = 4\n",
    "                if stv_abn_per >= 20 and stv_abn_per < 30:\n",
    "                    F = 2\n",
    "                if stv_abn_per >= 30 and stv_abn_per < 40:\n",
    "                    F = 1\n",
    "                if stv_abn_per >= 40 and stv_abn_per < 60:\n",
    "                    F = 0.5\n",
    "                if stv_abn_per >= 60:\n",
    "                    F = 1   \n",
    "                for i in range(1,imax):\n",
    "                    if f[i] >= 110 and f[i] < BL and h[i] > F*stv_abn_fr*h[0]:\n",
    "                        if f[i] < BL:\n",
    "                            BL = f[i]     \n",
    "                return BL     \n",
    "        else:\n",
    "            for i in range(1,imax):\n",
    "                if f[i] > 110 and h[i] > (1-stv_abn_fr) * (h[0] / 3):\n",
    "                    BL = f[i]\n",
    "                    return BL\n",
    "            for i in range(1,imax):\n",
    "                if f[i] < BL and h[i] > stv_abn_fr * h[0]:\n",
    "                    if f[i] < BL:\n",
    "                        BL = f[i]\n",
    "            return BL    \n",
    "\n",
    "    #Rounding to nearest 50\n",
    "    nfhr = [50 * round(x/50) for x in fhr]\n",
    "    #Re-scaling\n",
    "    nfhr = [x/100 for x in nfhr]\n",
    "    #Counting\n",
    "    h_count = Counter(nfhr)\n",
    "    #Sorting\n",
    "    h_count_sorted = dict(sorted(h_count.items(), key=lambda item: item[1],reverse=True))\n",
    "    #Getting frequencies\n",
    "    h_count_sorted.update((x,100*y/len(fhr)) for x,y in h_count_sorted.items())\n",
    "    #Filtering\n",
    "    hist = dict()\n",
    "    for (key, value) in h_count_sorted.items():\n",
    "        if value >= 0.8:\n",
    "            hist[key] = value\n",
    "    #Driver code\n",
    "    f = list(hist.keys())\n",
    "    h = list(hist.values())\n",
    "    imax = len(f)\n",
    "    BL = f[0]\n",
    "\n",
    "    return find_baseline(f,h,BL,imax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 795,
   "metadata": {},
   "outputs": [],
   "source": [
    "baseline = fhr_baseline_estimation(fhr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "h) Detection of accelerations and baseline shifts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 796,
   "metadata": {},
   "outputs": [],
   "source": [
    "def acceleration_detection(fhr, baseline):\n",
    "    #Detection of accelerations\n",
    "    acceleration_intervals = []\n",
    "    i = 0\n",
    "    while i+15*4 < len(fhr):\n",
    "        shifted_fhr = [x-baseline*100 for x in fhr[i:i+15*4]]\n",
    "        if all([x>0 for x in shifted_fhr]) == True:\n",
    "            shift = max(shifted_fhr)\n",
    "            j = i+15*4\n",
    "            while  j<len(fhr) and fhr[j]-baseline*100>0:\n",
    "                if fhr[j]-baseline*100>shift:\n",
    "                    shift = fhr[j]-baseline*100\n",
    "                j = j + 1\n",
    "            if shift > 15*100:\n",
    "                acceleration_intervals.append([i,j])\n",
    "            i = j\n",
    "        else:\n",
    "            i = i + 1\n",
    "    return acceleration_intervals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 797,
   "metadata": {},
   "outputs": [],
   "source": [
    "acceleration_intervals = acceleration_detection(fhr, baseline)\n",
    "aceleration_per_second = 4*len(acceleration_intervals)/len(fhr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "i) Detection and classification of decelerations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 798,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deceleration_detection(fhr, baseline):\n",
    "    #Detection of decelerations\n",
    "    deceleration_intervals = []\n",
    "    deceleration_total_time = 0\n",
    "    i = 0\n",
    "    while i+15*4 < len(fhr):\n",
    "        shifted_fhr = [x-baseline*100 for x in fhr[i:i+15*4]]\n",
    "        if all([x<0 for x in shifted_fhr]) == True:\n",
    "            shift = min(shifted_fhr)\n",
    "            j = i+15*4\n",
    "            while j<len(fhr) and fhr[j]-baseline*100<0:\n",
    "                if fhr[j]-baseline*100<shift:\n",
    "                    shift = fhr[j]-baseline*100\n",
    "                j = j + 1\n",
    "            if abs(shift) > 15*100:\n",
    "                deceleration_intervals.append([i,j])\n",
    "                deceleration_total_time = deceleration_total_time + j - i\n",
    "            i = j\n",
    "        else:\n",
    "            i = i + 1\n",
    "    return deceleration_intervals, deceleration_total_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 799,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deceleration_classification(deceleration_intervals):\n",
    "    #Classification of decelerations\n",
    "    mild_decelerations_number = 0\n",
    "    prolongued_decelerations_number = 0\n",
    "    severe_decelerations_number = 0\n",
    "\n",
    "    for d in deceleration_intervals:\n",
    "        diff = d[1] - d[0]\n",
    "        if diff <= 120:\n",
    "            mild_decelerations_number = mild_decelerations_number + 1\n",
    "        elif diff>120 and diff<=300:\n",
    "            prolongued_decelerations_number = prolongued_decelerations_number + 1\n",
    "        elif diff>300:\n",
    "            severe_decelerations_number = severe_decelerations_number + 1\n",
    "    \n",
    "    return mild_decelerations_number, prolongued_decelerations_number, severe_decelerations_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 800,
   "metadata": {},
   "outputs": [],
   "source": [
    "def late_deceleration_detection(fhr, baseline):\n",
    "    #Late decelerations\n",
    "    late_deceleration_intervals = []\n",
    "    late_deceleration_total_time = 0\n",
    "    i = 0\n",
    "    while i+15*4 < len(fhr):\n",
    "        shifted_fhr = [x-baseline*100 for x in fhr[i:i+15*4]]\n",
    "        if all([x<0 for x in shifted_fhr]) == True:\n",
    "            shift = min(shifted_fhr)\n",
    "            j = i+15*4\n",
    "            while j<len(fhr) and fhr[j]-baseline*100<0:\n",
    "                if fhr[j]-baseline*100<shift:\n",
    "                    shift = fhr[j]-baseline*100\n",
    "                j = j + 1\n",
    "            if abs(shift) > 15*100:\n",
    "                nadir = min(fhr[i:j])\n",
    "                nadir_ix = fhr.index(nadir)\n",
    "                if nadir_ix-i>30*4 and j-nadir_ix>30*4: \n",
    "                    late_deceleration_intervals.append([i,j])\n",
    "                    late_deceleration_total_time = late_deceleration_total_time + j - i\n",
    "            i = j\n",
    "        else:\n",
    "            i = i + 1\n",
    "\n",
    "    return late_deceleration_intervals, late_deceleration_total_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 801,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prolongued_deceleration_detection_2(deceleration_intervals):\n",
    "    #prolongued decelerations 2\n",
    "    prolongued_deceleration_intervals = []\n",
    "    prolongued_deceleration_total_time = 0\n",
    "    prolongued_deceleration_longest = 0\n",
    "\n",
    "    for d in deceleration_intervals:\n",
    "        diff = d[1] - d[0]\n",
    "        if diff > 3*60*4:\n",
    "            prolongued_deceleration_total_time = prolongued_deceleration_total_time + diff\n",
    "            prolongued_deceleration_intervals.append(d)\n",
    "            if diff > prolongued_deceleration_longest:\n",
    "                prolongued_deceleration_longest = diff\n",
    "    \n",
    "    return prolongued_deceleration_intervals, prolongued_deceleration_total_time, prolongued_deceleration_longest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 802,
   "metadata": {},
   "outputs": [],
   "source": [
    "deceleration_intervals, deceleration_total_time = deceleration_detection(fhr, baseline)\n",
    "\n",
    "mild_decelerations_number, prolongued_decelerations_number, severe_decelerations_number = deceleration_classification(deceleration_intervals)\n",
    "mild_decelerations_number_per_second = 4*mild_decelerations_number/len(fhr)\n",
    "prolongued_decelerations_number_per_second = 4*prolongued_decelerations_number/len(fhr)\n",
    "severe_decelerations_number_per_second = 4*severe_decelerations_number/len(fhr)\n",
    "\n",
    "late_deceleration_intervals, late_deceleration_total_time = late_deceleration_detection(fhr, baseline)\n",
    "prolongued_deceleration_intervals, prolongued_deceleration_total_time, prolongued_deceleration_longest = prolongued_deceleration_detection_2(deceleration_intervals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "h) Detection of abnormal and mean long-term variability (LTV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 803,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ltv_calculation(acceleration_intervals, deceleration_intervals, fhr):\n",
    "    def join_intervals(acceleration_intervals, deceleration_intervals):\n",
    "        #Join accelerations and decelerations\n",
    "        acceleration_intervals = interval(*acceleration_intervals)\n",
    "        deceleration_intervals = interval(*deceleration_intervals)\n",
    "        merged_interval = acceleration_intervals | deceleration_intervals\n",
    "        \n",
    "        # start = sorted([x[0] for x in intervals])\n",
    "        # end = sorted([x[1] for x in intervals]) \n",
    "        # merged_interval = []\n",
    "        # j = 0\n",
    "        # new_start = 0\n",
    "\n",
    "        # for i in range(len(start)):\n",
    "        #     if start[i]<end[j]:\n",
    "        #         continue\n",
    "        #     else:\n",
    "        #         j = j + 1\n",
    "        #         merged_interval.append([start[new_start], end[j]])\n",
    "        #         new_start = i\n",
    "\n",
    "        return merged_interval\n",
    "    \n",
    "    def complement_interval(merged):\n",
    "        if len(merged) > 0:\n",
    "            #Get complement of joined interval\n",
    "            start = sorted([x[0] for x in merged])\n",
    "            end = sorted([x[1] for x in merged]) \n",
    "            if start[0] == 0:\n",
    "                start.pop(0)\n",
    "                start.append(len(fhr))\n",
    "            if end[-1] == len(fhr):\n",
    "                end.pop(-1)\n",
    "                end.insert(0,0)\n",
    "\n",
    "            complement_intervals = []\n",
    "            for i in range(len(start)):\n",
    "                complement_intervals.append([end[i],start[i]])\n",
    "        else:\n",
    "            complement_intervals = [[0,len(fhr)]]\n",
    "        \n",
    "        return complement_intervals\n",
    "\n",
    "    #Get ltv\n",
    "    complement_intervals = complement_interval(join_intervals(acceleration_intervals,deceleration_intervals))\n",
    "    ltv = []\n",
    "    for c in complement_intervals:\n",
    "        diff = c[1] - c[0]\n",
    "        if diff >= 60*4:\n",
    "            i = 0\n",
    "            while i+60*4 <= diff:\n",
    "                ls = fhr[i:i+60*4]\n",
    "                max_value = max(ls)\n",
    "                min_value = min(ls)\n",
    "                ltv.append(max_value-min_value)\n",
    "                i = i + 1\n",
    "\n",
    "    if len(ltv) > 0:\n",
    "        #Get ltv mean\n",
    "        ltv_mean = np.mean(ltv)/100\n",
    "        #Get percentage of abnormal ltv\n",
    "        ltv_abnormal_per = 100*len([x for x in ltv if x <= 5*100])/len(ltv)\n",
    "    else:\n",
    "        ltv_mean = 0.0\n",
    "        ltv_abnormal_per = 0.0\n",
    "                \n",
    "    return complement_intervals, ltv_mean, ltv_abnormal_per"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 804,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduced_variability_check(complement_intervals, deceleration_intervals):\n",
    "    #Get ltv < 5 (reduced variability)\n",
    "    ltv_5_total_time = 0\n",
    "    for c in complement_intervals:\n",
    "        diff = c[1] - c[0]\n",
    "        if diff >= 60*4:\n",
    "            i = 0\n",
    "            while i+60*4 <= diff:\n",
    "                ls = fhr[i:i+60*4]\n",
    "                diff = max(ls) - min(ls)\n",
    "                if diff < 5*100:\n",
    "                    ltv_5_total_time = ltv_5_total_time + 1\n",
    "                i = i + 1\n",
    "\n",
    "    ltv_5_flg = False\n",
    "    if ltv_5_total_time > 50*60*4:\n",
    "        ltv_5_flg = True\n",
    "\n",
    "    #For decelerations\n",
    "    ltv_5_total_time_c = 0\n",
    "    for c in deceleration_intervals:\n",
    "        diff = c[1] - c[0]\n",
    "        if diff >= 60*4:\n",
    "            i = 0\n",
    "            while i+60*4 <= diff:\n",
    "                ls = fhr[i:i+60*4]\n",
    "                diff = max(ls) - min(ls)\n",
    "                if diff < 5*100:\n",
    "                    ltv_5_total_time_c = ltv_5_total_time_c + 1\n",
    "                i = i + 1\n",
    "\n",
    "    ltv_5_flg_c = False\n",
    "    if ltv_5_total_time_c > 3*60*4:\n",
    "        ltv_5_flg_c = True\n",
    "\n",
    "    return ltv_5_flg or ltv_5_flg_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 805,
   "metadata": {},
   "outputs": [],
   "source": [
    "def increased_variability_check(complement_intervals):\n",
    "    #Get ltv > 25 (increased variability)\n",
    "    ltv_25_time = 0\n",
    "    for c in complement_intervals:\n",
    "        diff = c[1] - c[0]\n",
    "        if diff >= 60*4:\n",
    "            i = 0\n",
    "            while i+60*4 <= diff:\n",
    "                ls = fhr[i:i+60*4]\n",
    "                diff = max(ls) - min(ls)\n",
    "                if diff > 25*100:\n",
    "                    ltv_25_time = ltv_25_time + 1\n",
    "                i = i + 1\n",
    "\n",
    "    ltv_25_flg = False\n",
    "    if ltv_25_flg > 30*60*4:\n",
    "        ltv_25_flg = True\n",
    "\n",
    "    return ltv_25_flg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 806,
   "metadata": {},
   "outputs": [],
   "source": [
    "complement_intervals, ltv_mean, ltv_abnormal_per = ltv_calculation(acceleration_intervals, deceleration_intervals, fhr)\n",
    "ltv_5_flg = reduced_variability_check(complement_intervals, deceleration_intervals)\n",
    "ltv_25_flg = increased_variability_check(complement_intervals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "i) Histogram properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 807,
   "metadata": {},
   "outputs": [],
   "source": [
    "def histogram_properties_calculation(fhr):\n",
    "    #Rounding to nearest 50\n",
    "    nfhr = [50 * round(x/50) for x in fhr]\n",
    "    #Re-scaling\n",
    "    nfhr = [x/100 for x in nfhr]\n",
    "\n",
    "    #Basic Properties\n",
    "    f, v = np.histogram(nfhr,bins=20)\n",
    "    h_min = min(np.delete(v,[0]))\n",
    "    h_max = max(v)\n",
    "    h_width = h_max - h_min\n",
    "\n",
    "    #Peaks\n",
    "    h_peaks = len(find_peaks(f)[0])\n",
    "\n",
    "    #Zeros\n",
    "    h_zeros = 0\n",
    "    i=0\n",
    "    while i < len(f):\n",
    "        if f[i] == 0:\n",
    "            j = i + 1\n",
    "            while j<len(f) and f[j] == 0:\n",
    "                j = j + 1\n",
    "            i = j\n",
    "            h_zeros = h_zeros + 1\n",
    "        else:\n",
    "            i = i + 1\n",
    "\n",
    "    #Stats\n",
    "    h_mean = np.mean(nfhr)\n",
    "    h_mode,_ = stats.mode(nfhr)\n",
    "    h_mode = h_mode[0]\n",
    "    h_median = np.median(nfhr)\n",
    "    h_variance = np.std(nfhr)\n",
    "\n",
    "    #Skew\n",
    "    skew = stats.skew(nfhr)\n",
    "    if skew<0.5 and skew>-0.5:\n",
    "        h_tendency = 0\n",
    "    elif skew>=0.5:\n",
    "        h_tendency = 1\n",
    "    elif skew<=-0.5:\n",
    "        h_tendency = -1\n",
    "\n",
    "    return h_width, h_min, h_max, h_peaks, h_zeros, h_mean, h_mode, h_median, h_variance, h_tendency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 808,
   "metadata": {},
   "outputs": [],
   "source": [
    "h_width, h_min, h_max, h_peaks, h_zeros, h_mean, h_mode, h_median, h_variance, h_tendency = histogram_properties_calculation(fhr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "j) Fetal Health"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./files/fetal_health.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 809,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Contractions association\n",
    "def interval_common(contraction_intervals,contraction_total_time,itvl):\n",
    "    contraction_intervals = interval(*contraction_intervals)\n",
    "    itvl = interval(*itvl)\n",
    "    intersection = contraction_intervals&itvl\n",
    "    intersection_total_time = 0\n",
    "    for i in intersection:\n",
    "        d =  i[1] - i[0]\n",
    "        intersection_total_time = intersection_total_time + d\n",
    "    if contraction_total_time > 0:\n",
    "        return intersection_total_time/contraction_total_time\n",
    "    else:\n",
    "        return 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 810,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fetal_health_fn(baseline, ltv_5_flg, ltv_25_flg, prolongued_deceleration_longest, contraction_intervals, contraction_total_time, late_deceleration_intervals, late_deceleration_total_time, prolongued_deceleration_intervals, prolongued_deceleration_total_time, ltv_mean, deceleration_intervals):\n",
    "    #pathological\n",
    "    baseline_tf = baseline<100\n",
    "    variability_tf = ltv_5_flg or ltv_25_flg\n",
    "    repetitive_tf = False\n",
    "    if prolongued_deceleration_longest > 5*60*4:\n",
    "        repetitive_tf = True   \n",
    "    elif ltv_5_flg == True:\n",
    "        if interval_common(contraction_intervals,contraction_total_time,late_deceleration_intervals) > 0.5 and late_deceleration_total_time > 20*60*4:\n",
    "            repetitive_tf = True\n",
    "        elif interval_common(contraction_intervals,contraction_total_time,prolongued_deceleration_intervals) > 0.5 and prolongued_deceleration_total_time > 20*60*4:\n",
    "            repetitive_tf = True\n",
    "    else:\n",
    "        if interval_common(contraction_intervals,contraction_total_time,late_deceleration_intervals) > 0.5 and late_deceleration_total_time > 30*60*4:\n",
    "            repetitive_tf = True\n",
    "        elif interval_common(contraction_intervals,contraction_total_time,prolongued_deceleration_intervals) > 0.5 and prolongued_deceleration_total_time > 30*60*4:\n",
    "            repetitive_tf = True\n",
    "    if baseline_tf or variability_tf or repetitive_tf == True:\n",
    "        return 3\n",
    "\n",
    "    #normal\n",
    "    baseline_tf = baseline>=110 and baseline<=160\n",
    "    variability_tf = ltv_mean>=5 and ltv_mean<=25\n",
    "    repetitive_tf = interval_common(contraction_intervals,contraction_total_time,deceleration_intervals) <= 0.5\n",
    "    if all([baseline_tf,variability_tf,repetitive_tf]) == True:\n",
    "        return 1\n",
    "    \n",
    "    #suspicious\n",
    "    return 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 811,
   "metadata": {},
   "outputs": [],
   "source": [
    "fetal_health = fetal_health_fn(baseline, ltv_5_flg, ltv_25_flg, prolongued_deceleration_longest, contraction_intervals, contraction_total_time, late_deceleration_intervals, late_deceleration_total_time, prolongued_deceleration_intervals, prolongued_deceleration_total_time, ltv_mean, deceleration_intervals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "k) Creating Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 812,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat_files = []\n",
    "hea_files = []\n",
    "for root, directories, files in os.walk(\"./physionet_dataset_processed\"):\n",
    "\tfor name in files:\n",
    "\t\tif \".mat\" in name:\n",
    "\t\t\tmat_files.append(os.path.join(root, name))\n",
    "\t\telif \".hea\" in name:\n",
    "\t\t\thea_files.append(os.path.join(root, name))\n",
    "mat_files = sorted(mat_files)\n",
    "hea_files = sorted(hea_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 813,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = []\n",
    "for file in mat_files:\n",
    "    mat = scipy.io.loadmat(file)\n",
    "\n",
    "    fhr = fhr_spike_removal(mat)\n",
    "\n",
    "    uc = filter_uterine_contractions(mat)\n",
    "\n",
    "    contraction_intervals, contraction_total_time = uterine_contraction_detection(uc)\n",
    "    contraction_number_per_second = 4*len(contraction_intervals)/len(uc)\n",
    "\n",
    "    stv_mean, stv_abn_per = stv_calculation(fhr)\n",
    "\n",
    "    fhr = filter_fhr_signals(fhr)\n",
    "\n",
    "    baseline = fhr_baseline_estimation(fhr)\n",
    "\n",
    "    acceleration_intervals = acceleration_detection(fhr, baseline)\n",
    "    aceleration_per_second = 4*len(acceleration_intervals)/len(fhr)\n",
    "\n",
    "    deceleration_intervals, deceleration_total_time = deceleration_detection(fhr, baseline)\n",
    "    mild_decelerations_number, prolongued_decelerations_number, severe_decelerations_number = deceleration_classification(deceleration_intervals)\n",
    "    mild_decelerations_number_per_second = 4*mild_decelerations_number/len(fhr)\n",
    "    prolongued_decelerations_number_per_second = 4*prolongued_decelerations_number/len(fhr)\n",
    "    severe_decelerations_number_per_second = 4*severe_decelerations_number/len(fhr)\n",
    "    late_deceleration_intervals, late_deceleration_total_time = late_deceleration_detection(fhr, baseline)\n",
    "    prolongued_deceleration_intervals, prolongued_deceleration_total_time, prolongued_deceleration_longest = prolongued_deceleration_detection_2(deceleration_intervals)\n",
    "\n",
    "    complement_intervals, ltv_mean, ltv_abnormal_per = ltv_calculation(acceleration_intervals, deceleration_intervals, fhr)\n",
    "    ltv_5_flg = reduced_variability_check(complement_intervals, deceleration_intervals)\n",
    "    ltv_25_flg = increased_variability_check(complement_intervals)\n",
    "\n",
    "    h_width, h_min, h_max, h_peaks, h_zeros, h_mean, h_mode, h_median, h_variance, h_tendency = histogram_properties_calculation(fhr)\n",
    "\n",
    "    fetal_health = fetal_health_fn(baseline, ltv_5_flg, ltv_25_flg, prolongued_deceleration_longest, contraction_intervals, contraction_total_time, late_deceleration_intervals, late_deceleration_total_time, prolongued_deceleration_intervals, prolongued_deceleration_total_time, ltv_mean, deceleration_intervals)    \n",
    "    \n",
    "    row = [baseline, aceleration_per_second, None, contraction_number_per_second, mild_decelerations_number_per_second, severe_decelerations_number_per_second, prolongued_decelerations_number_per_second, stv_abn_per, stv_mean, ltv_abnormal_per, ltv_mean, h_width, h_min, h_max, h_peaks, h_zeros, h_mode, h_mean, h_median, h_variance, h_tendency, fetal_health]\n",
    "\n",
    "    result.append(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.DataFrame(data=result,columns=[\"baseline value\",\"accelerations\",\"fetal_movement\",\"uterine_contractions\",\"light_decelerations\",\"severe_decelerations\",\"prolongued_decelerations\",\"abnormal_short_term_variability\",\"mean_value_of_short_term_variability\",\"percentage_of_time_with_abnormal_long_term_variability\",\"mean_value_of_long_term_variability\",\"histogram_width\",\"histogram_min\",\"histogram_max\",\"histogram_number_of_peaks\",\"histogram_number_of_zeroes\",\"histogram_mode\",\"histogram_mean\",\"histogram_median\",\"histogram_variance\",\"histogram_tendency\",\"fetal_health\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MAT files with no UC signal (deleted)\n",
    "1104\n",
    "1119\n",
    "1149\n",
    "1155\n",
    "1186\n",
    "1188\n",
    "1258\n",
    "1327"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "l) Other data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Other info\n",
    "result = []\n",
    "for file in hea_files:\n",
    "    f = open(file, 'r')\n",
    "    lines = f.readlines()\n",
    "    cnt = 0\n",
    "    for line in lines:\n",
    "        if \"#pH\" in line:\n",
    "            val_1 = float(line.strip(\"#pH\").strip())\n",
    "            continue\n",
    "        if \"#BDecf\" in line:\n",
    "            val_2 = float(line.strip(\"#BDecf\").strip())\n",
    "            continue\n",
    "        if \"#pCO2\" in line:\n",
    "            val_3 = float(line.strip(\"#pCO2\").strip())\n",
    "            continue\n",
    "        if \"#BE\" in line:\n",
    "            val_4 = float(line.strip(\"#BE\").strip())\n",
    "            continue\n",
    "        if \"#Apgar1\" in line:\n",
    "            val_5 = int(line.strip(\"#Apgar1\").strip())\n",
    "            continue\n",
    "        if \"#Apgar5\" in line:\n",
    "            val_6 = int(line.strip(\"#Apgar5\").strip())\n",
    "            continue\n",
    "        if \"#Gest. weeks\" in line:\n",
    "            val_7 = int(line.strip(\"#Gest. weeks\").strip())\n",
    "            continue\n",
    "        if \"#Weight(g)\" in line:\n",
    "            try:\n",
    "                val_8 = int(line.strip(\"#Weight(g)\").strip())\n",
    "            except:\n",
    "                val_8 = None\n",
    "            continue\n",
    "        if \"#Sex\" in line:\n",
    "            val_9 = int(line.strip(\"#Sex\").strip())\n",
    "            continue\n",
    "        if \"#Age\" in line:\n",
    "            val_10 = int(line.strip(\"#Age\").strip())\n",
    "            continue\n",
    "        if \"#Gravidity\" in line:\n",
    "            try:\n",
    "                val_11 = int(line.strip(\"#Gravidity\").strip())\n",
    "            except:\n",
    "                val_11 = None\n",
    "            continue\n",
    "        if \"#Parity\" in line:\n",
    "            val_12 = int(line.strip(\"#Parity\").strip())\n",
    "            continue\n",
    "        if \"#Diabetes\" in line:\n",
    "            val_13 = int(line.strip(\"#Diabetes\").strip())\n",
    "            continue\n",
    "        if \"#Hypertension\" in line:\n",
    "            val_14 = int(line.strip(\"#Hypertension\").strip())\n",
    "            continue\n",
    "        if \"#Preeclampsia\" in line:\n",
    "            val_15 = int(line.strip(\"#Preeclampsia\").strip())\n",
    "            continue\n",
    "        if \"#Liq. praecox\" in line:\n",
    "            val_16 = int(line.strip(\"#Liq. praecox\").strip())\n",
    "            continue\n",
    "        if \"#Pyrexia\" in line:\n",
    "            val_17 = int(line.strip(\"#Pyrexia\").strip())\n",
    "            continue\n",
    "        if \"#Meconium\" in line:\n",
    "            val_18 = int(line.strip(\"#Meconium\").strip())\n",
    "            continue\n",
    "        if \"#Presentation\" in line:\n",
    "            try:\n",
    "                val_19 = int(line.strip(\"#Presentation\").strip())\n",
    "            except:\n",
    "                val_19 = None\n",
    "            continue\n",
    "        if \"#Induced\" in line:\n",
    "            val_20 = int(line.strip(\"#Induced\").strip())\n",
    "            continue\n",
    "        if \"#I.stage\" in line:\n",
    "            val_21 = int(line.strip(\"#I.stage\").strip())\n",
    "            continue\n",
    "        if \"#NoProgress\" in line:\n",
    "            val_22 = int(line.strip(\"#NoProgress\").strip())\n",
    "            continue\n",
    "        if \"#CK/KP\" in line:\n",
    "            val_23 = int(line.strip(\"#CK/KP\").strip())\n",
    "            continue\n",
    "        if \"#II.stage\" in line:\n",
    "            val_24 = int(line.strip(\"#II.stage\").strip())\n",
    "            continue\n",
    "        if \"#Deliv. type\" in line:\n",
    "            val_25 = int(line.strip(\"#Deliv. type\").strip())\n",
    "            continue\n",
    "\n",
    "        continue\n",
    "    result.append([val_1, val_2, val_3, val_4, val_5, val_6, val_7, val_8, val_9, val_10, val_11, val_12, val_13, val_14, val_15, val_16, val_17, val_18, val_19, val_20, val_21, val_22, val_23, val_24, val_25])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "apgar = pd.DataFrame(data=result, columns=[\"pH\",\"BDecf\",\"pCO2\",\"BE\",\"Apgar1\", \"Apgar5\", \"Gest. weeks\", \"Weight(g)\", \"Sex\", \"Age\", \"Gravidity\", \"Parity\", \"Diabetes\", \"Hypertension\", \"Preeclampsia\", \"Liq. praecox\", \"Pyrexia\", \"Meconium\", \"Presentation\", \"Induced\", \"I.stage\", \"NoProgress\", \"CK/KP\", \"II.stage\", \"Deliv. type\"])\n",
    "dataset = pd.merge(dataset, apgar, left_index=True, right_index=True)\n",
    "dataset.to_csv(\"./second_dataset.csv\", index=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./files/apgar.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#past code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import numpy as np\n",
    "from sklearn.mixture import GaussianMixture as GMM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fd = pd.read_csv(\"./second_dataset.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['baseline value', 'accelerations', 'fetal_movement',\n",
       "       'uterine_contractions', 'light_decelerations', 'severe_decelerations',\n",
       "       'prolongued_decelerations', 'abnormal_short_term_variability',\n",
       "       'mean_value_of_short_term_variability',\n",
       "       'percentage_of_time_with_abnormal_long_term_variability',\n",
       "       'mean_value_of_long_term_variability', 'histogram_width',\n",
       "       'histogram_min', 'histogram_max', 'histogram_number_of_peaks',\n",
       "       'histogram_number_of_zeroes', 'histogram_mode', 'histogram_mean',\n",
       "       'histogram_median', 'histogram_variance', 'histogram_tendency',\n",
       "       'fetal_health', 'pH', 'BDecf', 'pCO2', 'BE', 'Apgar1', 'Apgar5',\n",
       "       'Gest. weeks', 'Weight(g)', 'Sex', 'Age', 'Gravidity', 'Parity',\n",
       "       'Diabetes', 'Hypertension', 'Preeclampsia', 'Liq. praecox', 'Pyrexia',\n",
       "       'Meconium', 'Presentation', 'Induced', 'I.stage', 'NoProgress', 'CK/KP',\n",
       "       'II.stage', 'Deliv. type'],\n",
       "      dtype='object')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fd.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fd_test = fd.drop(columns=['fetal_health'])\n",
    "#fd_test = fd[fd['fetal_health']==3.0].drop(columns=['fetal_health'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fd = fd[['baseline value', 'accelerations',\n",
    "       'uterine_contractions', 'light_decelerations', 'severe_decelerations',\n",
    "       'prolongued_decelerations', 'abnormal_short_term_variability',\n",
    "       'mean_value_of_short_term_variability',\n",
    "       'percentage_of_time_with_abnormal_long_term_variability',\n",
    "       'mean_value_of_long_term_variability', 'histogram_width',\n",
    "       'histogram_min', 'histogram_max', 'histogram_number_of_peaks',\n",
    "       'histogram_number_of_zeroes', 'histogram_mode', 'histogram_mean',\n",
    "       'histogram_median', 'histogram_variance', 'histogram_tendency',\n",
    "       'fetal_health']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fd = fd[fd['fetal_health']==3.0]\n",
    "fd = fd[['baseline value', 'accelerations',\n",
    "       'uterine_contractions', 'light_decelerations', 'severe_decelerations',\n",
    "       'prolongued_decelerations', 'abnormal_short_term_variability',\n",
    "       'mean_value_of_short_term_variability',\n",
    "       'percentage_of_time_with_abnormal_long_term_variability',\n",
    "       'mean_value_of_long_term_variability', 'histogram_width',\n",
    "       'histogram_min', 'histogram_max', 'histogram_number_of_peaks',\n",
    "       'histogram_number_of_zeroes', 'histogram_mode', 'histogram_mean',\n",
    "       'histogram_median', 'histogram_variance', 'histogram_tendency']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_components = np.arange(1, 21)\n",
    "models = [GMM(n, covariance_type='full', random_state=0).fit(fd)\n",
    "          for n in n_components]\n",
    "\n",
    "plt.plot(n_components, [m.bic(fd) for m in models], label='BIC')\n",
    "plt.plot(n_components, [m.aic(fd) for m in models], label='AIC')\n",
    "plt.legend(loc='best')\n",
    "plt.xlabel('n_components')\n",
    "plt.savefig('ic.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gmm = GMM(n_components=2, covariance_type='full', random_state=0).fit(fd)\n",
    "labels = gmm.predict(fd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.manifold import TSNE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[t-SNE] Computing 121 nearest neighbors...\n",
      "[t-SNE] Indexed 189 samples in 0.001s...\n",
      "[t-SNE] Computed neighbors for 189 samples in 0.005s...\n",
      "[t-SNE] Computed conditional probabilities for sample 189 / 189\n",
      "[t-SNE] Mean sigma: 28.102248\n",
      "[t-SNE] KL divergence after 250 iterations with early exaggeration: 57.101711\n",
      "[t-SNE] KL divergence after 300 iterations: 0.568882\n"
     ]
    }
   ],
   "source": [
    "tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)\n",
    "tsne_results = tsne.fit_transform(fd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='tsne-2d-one', ylabel='tsne-2d-two'>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame()\n",
    "df['tsne-2d-one'] = tsne_results[:,0]\n",
    "df['tsne-2d-two'] = tsne_results[:,1]\n",
    "plt.figure(figsize=(16,10))\n",
    "sns.scatterplot(\n",
    "    x=\"tsne-2d-one\", y=\"tsne-2d-two\",\n",
    "    #hue=\"y\",\n",
    "    palette=sns.color_palette(\"hls\", 10),\n",
    "    data=df,\n",
    "    legend=\"full\",\n",
    "    alpha=0.3\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#sc = plt.scatter(tsne_results[:,0], tsne_results[:,1], c=fd['fetal_health'].to_list(), s=5, cmap='viridis', label=fd['fetal_health'].to_list())\n",
    "sc = plt.scatter(tsne_results[:,0], tsne_results[:,1], s=5)\n",
    "plt.legend(*sc.legend_elements())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(tsne_results[:,0], tsne_results[:,1], c=labels, s=5, cmap='copper')\n",
    "plt.savefig('gmm_p.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fd = pd.read_csv(\"./fetal_health.csv\")\n",
    "fd_test = fd.drop(columns=['fetal_health'])\n",
    "fd_test_p = fd[fd['fetal_health']==3.0].drop(columns=['fetal_health'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "fd_test_sc = scaler.fit_transform(fd_test_p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PCA(n_components=5)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pca = PCA(n_components=5)\n",
    "pca.fit(fd_test_sc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.4774393  0.09576925 0.08128491 0.06637271 0.04836218]\n"
     ]
    }
   ],
   "source": [
    "print(pca.explained_variance_ratio_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>fetal_movement</th>\n",
       "      <th>baseline value</th>\n",
       "      <th>prolongued_decelerations</th>\n",
       "      <th>histogram_max</th>\n",
       "      <th>histogram_mode</th>\n",
       "      <th>histogram_median</th>\n",
       "      <th>mean_value_of_long_term_variability</th>\n",
       "      <th>histogram_number_of_peaks</th>\n",
       "      <th>histogram_mean</th>\n",
       "      <th>histogram_variance</th>\n",
       "      <th>...</th>\n",
       "      <th>histogram_width</th>\n",
       "      <th>mean_value_of_short_term_variability</th>\n",
       "      <th>accelerations</th>\n",
       "      <th>uterine_contractions</th>\n",
       "      <th>histogram_min</th>\n",
       "      <th>percentage_of_time_with_abnormal_long_term_variability</th>\n",
       "      <th>histogram_number_of_zeroes</th>\n",
       "      <th>light_decelerations</th>\n",
       "      <th>abnormal_short_term_variability</th>\n",
       "      <th>severe_decelerations</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.40543</td>\n",
       "      <td>-0.341187</td>\n",
       "      <td>-0.279</td>\n",
       "      <td>-0.264246</td>\n",
       "      <td>-0.211292</td>\n",
       "      <td>-0.210802</td>\n",
       "      <td>-0.208919</td>\n",
       "      <td>-0.198229</td>\n",
       "      <td>-0.185313</td>\n",
       "      <td>-0.155487</td>\n",
       "      <td>...</td>\n",
       "      <td>-0.124035</td>\n",
       "      <td>-0.063557</td>\n",
       "      <td>-0.023009</td>\n",
       "      <td>-0.001327</td>\n",
       "      <td>0.010511</td>\n",
       "      <td>0.069627</td>\n",
       "      <td>0.089033</td>\n",
       "      <td>0.255738</td>\n",
       "      <td>0.32811</td>\n",
       "      <td>0.341543</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 21 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   fetal_movement  baseline value  prolongued_decelerations  histogram_max  \\\n",
       "1        -0.40543       -0.341187                    -0.279      -0.264246   \n",
       "\n",
       "   histogram_mode  histogram_median  mean_value_of_long_term_variability  \\\n",
       "1       -0.211292         -0.210802                            -0.208919   \n",
       "\n",
       "   histogram_number_of_peaks  histogram_mean  histogram_variance  ...  \\\n",
       "1                  -0.198229       -0.185313           -0.155487  ...   \n",
       "\n",
       "   histogram_width  mean_value_of_short_term_variability  accelerations  \\\n",
       "1        -0.124035                             -0.063557      -0.023009   \n",
       "\n",
       "   uterine_contractions  histogram_min  \\\n",
       "1             -0.001327       0.010511   \n",
       "\n",
       "   percentage_of_time_with_abnormal_long_term_variability  \\\n",
       "1                                           0.069627        \n",
       "\n",
       "   histogram_number_of_zeroes  light_decelerations  \\\n",
       "1                    0.089033             0.255738   \n",
       "\n",
       "   abnormal_short_term_variability  severe_decelerations  \n",
       "1                          0.32811              0.341543  \n",
       "\n",
       "[1 rows x 21 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.DataFrame(pca.components_, columns=fd_test.columns)[1:2].sort_values(by=1,axis=1)\n",
    "#vcr[2:3].sort_values(by=2,axis=1).to_csv('./3.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PCA(n_components=10)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pca = PCA(n_components=10)\n",
    "pca.fit(fd_test_p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7.50763548e-01, 1.24690579e-01, 5.15891348e-02, 2.88948457e-02,\n",
       "       2.13680496e-02, 1.04793698e-02, 5.88459950e-03, 3.00805019e-03,\n",
       "       2.34867849e-03, 6.09396709e-04])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pca.explained_variance_ratio_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>histogram_width</th>\n",
       "      <th>histogram_number_of_peaks</th>\n",
       "      <th>abnormal_short_term_variability</th>\n",
       "      <th>mean_value_of_short_term_variability</th>\n",
       "      <th>histogram_number_of_zeroes</th>\n",
       "      <th>mean_value_of_long_term_variability</th>\n",
       "      <th>light_decelerations</th>\n",
       "      <th>uterine_contractions</th>\n",
       "      <th>prolongued_decelerations</th>\n",
       "      <th>severe_decelerations</th>\n",
       "      <th>...</th>\n",
       "      <th>fetal_movement</th>\n",
       "      <th>histogram_tendency</th>\n",
       "      <th>histogram_max</th>\n",
       "      <th>histogram_mode</th>\n",
       "      <th>baseline value</th>\n",
       "      <th>histogram_median</th>\n",
       "      <th>histogram_mean</th>\n",
       "      <th>histogram_min</th>\n",
       "      <th>percentage_of_time_with_abnormal_long_term_variability</th>\n",
       "      <th>histogram_variance</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.277093</td>\n",
       "      <td>-0.015583</td>\n",
       "      <td>-0.011592</td>\n",
       "      <td>-0.008195</td>\n",
       "      <td>-0.003616</td>\n",
       "      <td>-0.000396</td>\n",
       "      <td>-0.000025</td>\n",
       "      <td>-0.000011</td>\n",
       "      <td>-0.000006</td>\n",
       "      <td>-3.094298e-07</td>\n",
       "      <td>...</td>\n",
       "      <td>0.000138</td>\n",
       "      <td>0.001622</td>\n",
       "      <td>0.050733</td>\n",
       "      <td>0.077023</td>\n",
       "      <td>0.114895</td>\n",
       "      <td>0.198134</td>\n",
       "      <td>0.248182</td>\n",
       "      <td>0.327826</td>\n",
       "      <td>0.331922</td>\n",
       "      <td>0.763255</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 21 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   histogram_width  histogram_number_of_peaks  \\\n",
       "1        -0.277093                  -0.015583   \n",
       "\n",
       "   abnormal_short_term_variability  mean_value_of_short_term_variability  \\\n",
       "1                        -0.011592                             -0.008195   \n",
       "\n",
       "   histogram_number_of_zeroes  mean_value_of_long_term_variability  \\\n",
       "1                   -0.003616                            -0.000396   \n",
       "\n",
       "   light_decelerations  uterine_contractions  prolongued_decelerations  \\\n",
       "1            -0.000025             -0.000011                 -0.000006   \n",
       "\n",
       "   severe_decelerations  ...  fetal_movement  histogram_tendency  \\\n",
       "1         -3.094298e-07  ...        0.000138            0.001622   \n",
       "\n",
       "   histogram_max  histogram_mode  baseline value  histogram_median  \\\n",
       "1       0.050733        0.077023        0.114895          0.198134   \n",
       "\n",
       "   histogram_mean  histogram_min  \\\n",
       "1        0.248182       0.327826   \n",
       "\n",
       "   percentage_of_time_with_abnormal_long_term_variability  histogram_variance  \n",
       "1                                           0.331922                 0.763255  \n",
       "\n",
       "[1 rows x 21 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.DataFrame(pca.components_, columns=fd_test.columns)[1:2].sort_values(by=1,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "pca = PCA().fit(fd_test_sc)\n",
    "\n",
    "plt.plot(np.cumsum(pca.explained_variance_ratio_))\n",
    "plt.xlabel('Number of components')\n",
    "plt.ylabel('Cumulative explained variance')\n",
    "plt.grid(True)\n",
    "plt.savefig('./pca.png')\n",
    "plt.rc('grid', linestyle=\":\", color='black')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ac750e7546c43045a4c2a4a51d6ff271a4f7806cc184dcaeaa8a03025e690f95"
  },
  "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": 2
}