Notebook

In [1]:

import pandas as pd
import os
import numpy as np

In [2]:

targets_path=r"C:\Users\jeuux\Desktop\Carrera\MoAI\TFM\AnnotatedData\Accelerometer_Data\Datasets\HAR_Dataset\targets.npy"

In [54]:

targets=np.load(targets_path)

In [45]:

#get list of targets
target_list=np.unique(targets)

#split target hierarchy inside each target (eg. ['AG Cp Av Cl'] --> ['AG', 'Cp', 'Av', 'Cl'] )
targets_list=list(map(lambda target: target.split(" "),target_list))

#selects targets inside current hierarchy
targets_used = list(filter(lambda x: "Or" in x, targets))

In [27]:

#split target hierarchy inside each target (eg. ['AG Cp Av Cl'] --> ['AG', 'Cp', 'Av', 'Cl'] )
def _split_target_hierarchy(target_list):
    return list(map(lambda target: target.split(" "),target_list))
def _filter_levels(target,pos):
    target=target[:pos+2]
    return " ".join(target)

In [46]:

#2nd step
level="Or"
#split hierarchy
targets_used=_split_target_hierarchy(targets_used)
#get pos...
target_ex=targets_used[0]
pos=next(idx for idx,_ in enumerate(target_ex) if level==target_ex[idx])
#filter levels
targets_used=list(map(lambda target: _select_levels(target,pos) ,targets_used))

Transformer¶

In [71]:

import numpy as np 
from sklearn.base import BaseEstimator, TransformerMixin


class LevelSelector( BaseEstimator, TransformerMixin):
    """Custom Transformer that select the group of behaviours inside a level hierarchy"""

    #Class Constructor 
    def __init__( self,level):
        self._level=level
        
    def _split_target_hierarchy(self,target_list):
        """split target hierarchy inside each target 
        (eg. ['AG Cp Av Cl'] --> ['AG', 'Cp', 'Av', 'Cl'] )"""
        return list(map(lambda target: target.split(" "),target_list))
    
    def _filter_levels(self,target,pos):
        target=target[:pos+2]
        return " ".join(target)
    
    def _get_pos(self,y):
        y_first=y[0]
        return next(idx for idx,_ in enumerate(y_first) if self._level==y_first[idx])

    def _get_valid_idx(self,y):
        return [idx for idx,target in enumerate (y) if self._level in target]

    def fit(self,y):
        return self 
    
    def transform( self, y ):
        #filter behaviours
        self.valid_idx= self._get_valid_idx(y)
        y = y[self.valid_idx]
        #split hierarchy
        y=self._split_target_hierarchy(y)
        #get pos
        pos=self._get_pos(y)
        #filter levels
        y=list(map(lambda target: self._filter_levels(target,pos) ,y))
        return  y

In [72]:

level_sel=LevelSelector(level="Or")

In [73]:

targets_filtered=level_sel.transform(targets)

In [75]:

level_sel.valid_idx

Out[75]:

In [70]:

Out[70]:

array(['AG Or Ma Sc Ab', 'AG Cp Ce', 'AG Cp Ce', ..., 'AG Or Mi Os',
       'AG Or Mi Os', 'AG Or Mi Os'], dtype='<U32')

In [69]:

Out[69]: