Exemple #1
0
    def generate_affine_backtransformation(self):
        """ Generate synthetic examples and test them to determine transformation

        This is the key method!
        """
        if type(self.example) == FeatureVector:
            testsample = FeatureVector.replace_data(
                self.example, numpy.zeros(self.example.shape))
            self.offset = numpy.longdouble(self._execute(testsample))
            self.trafo = FeatureVector.replace_data(
                self.example, numpy.zeros(self.example.shape))
            for j in range(len(self.example.feature_names)):
                testsample = FeatureVector.replace_data(
                    self.example,
                    numpy.zeros(self.example.shape))
                testsample[0][j] = 1.0
                self.trafo[0][j] = \
                    numpy.longdouble(self._execute(testsample) - self.offset)
        elif type(self.example) == TimeSeries:
            testsample = TimeSeries.replace_data(
                self.example, numpy.zeros(self.example.shape))
            self.offset = numpy.longdouble(numpy.squeeze(
                self._execute(testsample)))
            self.trafo = TimeSeries.replace_data(
                self.example, numpy.zeros(self.example.shape))
            for i in range(self.example.shape[0]):
                for j in range(self.example.shape[1]):
                    testsample = TimeSeries.replace_data(
                        self.example, numpy.zeros_like(self.example))
                    testsample[i][j] = 1.0
                    self.trafo[i][j] = \
                        numpy.longdouble(numpy.squeeze(self._execute(testsample))
                                       - self.offset)
Exemple #2
0
 def _execute(self, data):
     """ Apply the windowing to the given data and return the result """        
     #Create a window of the correct length for the given data
     if self.num_of_samples is None:
         self.num_of_samples = data.shape[0]
         self.create_window_array()
          
     data_array=data.view(numpy.ndarray)
     #Do the actual windowing
     # TODO: check if windowed_data = (self.window_array.T * data) works also???
     windowed_data = (self.window_array * data_array.T).T
     
     # Skip trailing zeros
     if self.window_has_zeros and self.reduce_window:
         windowed_data = windowed_data[
             range(self.window_not_equal_zero[0],
                   self.window_not_equal_zero[-1] + 1), :]
     
         result_time_series = TimeSeries.replace_data(data, windowed_data)
         
         # Adjust start and end time when chopping was done
         result_time_series.start_time = data.start_time + \
             self.window_not_equal_zero[0] * 1000.0 / data.sampling_frequency
         result_time_series.end_time = \
             data.end_time - (data.shape[0] - self.window_not_equal_zero[-1]
                              - 1) * 1000.0 / data.sampling_frequency
     else:
         result_time_series = TimeSeries.replace_data(data, windowed_data)
                 
     return result_time_series
Exemple #3
0
    def generate_affine_backtransformation(self):
        """ Generate synthetic examples and test them to determine transformation

        This is the key method!
        """
        if type(self.example) == FeatureVector:
            testsample = FeatureVector.replace_data(
                self.example, numpy.zeros(self.example.shape))
            self.offset = numpy.longdouble(self._execute(testsample))
            self.trafo = FeatureVector.replace_data(
                self.example, numpy.zeros(self.example.shape))
            for j in range(len(self.example.feature_names)):
                testsample = FeatureVector.replace_data(
                    self.example, numpy.zeros(self.example.shape))
                testsample[0][j] = 1.0
                self.trafo[0][j] = \
                    numpy.longdouble(self._execute(testsample) - self.offset)
        elif type(self.example) == TimeSeries:
            testsample = TimeSeries.replace_data(
                self.example, numpy.zeros(self.example.shape))
            self.offset = numpy.longdouble(
                numpy.squeeze(self._execute(testsample)))
            self.trafo = TimeSeries.replace_data(
                self.example, numpy.zeros(self.example.shape))
            for i in range(self.example.shape[0]):
                for j in range(self.example.shape[1]):
                    testsample = TimeSeries.replace_data(
                        self.example, numpy.zeros_like(self.example))
                    testsample[i][j] = 1.0
                    self.trafo[i][j] = \
                        numpy.longdouble(numpy.squeeze(self._execute(testsample))
                                       - self.offset)
Exemple #4
0
    def _execute(self, data):
        """ Perform a shift and normalization according
        (whole_data - mean(specific_samples)) / std(specific_samples)
        """
        if self.devariance:
            # code copy from LocalStandardizationNode
            std = numpy.std(data[self.subset],axis=0)
            std = check_zero_division(self, std, tolerance=10**-15, data_ts=data)

            return TimeSeries.replace_data(data,
                        (data-numpy.mean(data[self.subset], axis=0)) / std)
        else:
            return TimeSeries.replace_data(data, \
                        data-numpy.mean(data[self.subset], axis=0))
   def _execute(self, x):
       """ Apply high pass filter to data x and return the result """

       #Determine the indices of the channels which will be filtered
       selected_channel_names =  self.selected_channels \
                           if self.selected_channels != None else x.channel_names
       selected_channel_indices = [x.channel_names.index(channel_name) \
                                      for channel_name in selected_channel_names]
       if self.b is None:
       #Compute the FIR window which is required for the high pass filter
            try:
                b = scipy.signal.firwin(numtaps = self.taps,
                                   cutoff = self.cutoff_frequency * 2.0 / x.sampling_frequency,
                                   width = self.width,
                                   window = self.window)
            except TypeError:
                b = scipy.signal.firwin(N = self.taps-1,
                                   cutoff = self.cutoff_frequency * 2.0 / x.sampling_frequency,
                                   width = self.width,
                                   window = self.window)
            b = -b
            b[self.taps/2] = b[self.taps/2]+1
            self.set_permanent_attributes(b=b)

       #Do the actual filtering
       y=x.view(numpy.ndarray)
       filtered_data = numpy.zeros(x.shape)
       for channel_index in selected_channel_indices:
           filtered_data[:,channel_index] = \
                                 scipy.signal.lfilter(self.b, [1], y[:,channel_index])

       result_time_series = TimeSeries.replace_data(x, filtered_data)

       return result_time_series
Exemple #6
0
    def _execute(self, x):
        """ Compute the energy of the given signal x using the TKEO """
        # Determine the indices of the channels which will be filtered
        # Done only once...
        if self.selected_channel_indices is None:
            self.selected_channels = self.selected_channels \
            if self.selected_channels != None else x.channel_names
            self.selected_channel_indices = [x.channel_names.index(channel_name) \
                                            for channel_name in self.selected_channels]
            self.old_data = numpy.zeros(
                (2, len(self.selected_channel_indices)))

        filtered_data = numpy.zeros(x.shape)
        channel_counter = -1
        for channel_index in self.selected_channel_indices:
            channel_counter += 1
            for i in range(len(x)):
                if i == 0:
                    filtered_data[i][channel_index] = \
                        math.pow(self.old_data[1][channel_counter],2) - (
                        self.old_data[0][channel_counter] * x[0][channel_index])
                elif i == 1:
                    filtered_data[i][channel_index] = \
                        math.pow(x[0][channel_index],2) - (
                        self.old_data[1][channel_counter] * x[1][channel_index])
                else:
                    filtered_data[i][channel_index] = \
                    math.pow(x[i-1][channel_index],2) - (
                    x[i-2][channel_index] * x[i][channel_index])
            self.old_data[0][channel_counter] = x[-2][channel_index]
            self.old_data[1][channel_counter] = x[-1][channel_index]
        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #7
0
    def _execute(self, data):
        """ Apply the :func:`scipy.signal.lfilter` function with the DC removal coefficients on the data """
        #Determine the indices of the channels which will be filtered
        if self.selected_channel_indices is None:
            self.selected_channel_names = self.selected_channels \
                if self.selected_channels is not None else data.channel_names
            self.selected_channel_indices = [
                data.channel_names.index(channel_name)
                for channel_name in self.selected_channel_names]

        # create initial filter conditions for all channels
        if self.internal_state is None:
            self.internal_state = dict()
            for channel_index in xrange(data.shape[1]):
                self.internal_state[channel_index] = \
                    scipy.signal.lfiltic(self.b, self.a, [0, 0])

        # do the actual removal
        cleaned_data = numpy.zeros(data.shape)
        for channel_index in self.selected_channel_indices:
            (cleaned_data[:, channel_index],
             self.internal_state[channel_index]) = \
                scipy.signal.lfilter(self.b, self.a, data[:, channel_index],
                                     zi=self.internal_state[channel_index])

        result_time_series = TimeSeries.replace_data(data, cleaned_data)

        return result_time_series
    def _execute(self, x):
        """ Apply low pass filter to data x and return the result """
        #Determine the indices of the channels which will be filtered
        selected_channel_names =  self.selected_channels \
                           if self.selected_channels != None else x.channel_names
        selected_channel_indices = [x.channel_names.index(channel_name) \
                                      for channel_name in selected_channel_names]

        # Compute the FIR window which is required for the low pass filter
        # This is quite slow!
        # filter_order = 2 * x.sampling_frequency / self.cutoff_frequency
        filter_order = 31
        if self.b is None:
            try:
                b = \
                    scipy.signal.firwin(numtaps = filter_order,
                                    cutoff = self.cutoff_frequency * 2.0 / x.sampling_frequency,
                                    width = self.width,
                                    window = self.window)
            except TypeError:
                b = \
                    scipy.signal.firwin(N = filter_order-1,
                                    cutoff = self.cutoff_frequency * 2.0 / x.sampling_frequency,
                                    width = self.width,
                                    window = self.window)
            self.set_permanent_attributes(b=b)
        #Do the actual filtering
        filtered_data = numpy.zeros(x.shape)
        y=x.view(type=numpy.ndarray)
        for channel_index in selected_channel_indices:
            filtered_data[:,channel_index] = scipy.signal.convolve(self.b, \
                              y[:,channel_index])[len(self.b)/2:-len(self.b)/2+1]
        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #9
0
    def merge_time_series(self, input_collection):
        """ Merges all timeseries of the input_collection to one big timeseries """
        # Retriev the time series from the input_collection
        input_timeseries = input_collection.get_data(0, 0, 'test')
        # Get the data from the first timeseries
        output_data = input_timeseries[0][0].get_data()
        # Change the endtime of the first timeseries to the one of the last
        # timeseries inside the input_collection
        input_timeseries[0][0].end_time = input_timeseries[-1][0].end_time
        # For all the remaining timeseries
        for ts in input_timeseries[1:]:
            # Concatenate the data...
            output_data = numpy.vstack((output_data, ts[0].get_data()))
            # ... and add the marker to the first timeseries
            if (len(ts[0].marker_name) > 0):
                for k in ts[0].marker_name:
                    if (not input_timeseries[0][0].marker_name.has_key(k)):
                        input_timeseries[0][0].marker_name[k] = []
                    for time in ts[0].marker_name[k]:
                        input_timeseries[0][0].marker_name[k].append(
                            time + ts[0].start_time +
                            input_timeseries[0][0].start_time)
        # Use the meta information from the first timeseries e.g. marker start/end_time
        # and create a new timeseries with the concatenated data
        merged_time_series = TimeSeries.replace_data(input_timeseries[0][0],
                                                     output_data)
        # Change the name of the merged_time_series
        merged_time_series.name = "%s, length %d ms, %s" % (merged_time_series.name.split(',')[0], \
                                                            (len(merged_time_series)*1000.0)/merged_time_series.sampling_frequency,\
                                                            merged_time_series.name.split(',')[-1])

        return merged_time_series
Exemple #10
0
    def _execute(self, x):
        """ Apply low pass filter to data x and return the result """
        #Determine the indices of the channels which will be filtered
        selected_channel_names =  self.selected_channels \
                           if self.selected_channels != None else x.channel_names
        selected_channel_indices = [x.channel_names.index(channel_name) \
                                      for channel_name in selected_channel_names]

        # Compute the FIR window which is required for the low pass filter
        # This is quite slow!
        # filter_order = 2 * x.sampling_frequency / self.cutoff_frequency
        filter_order = 31
        if self.b is None:
            try:
                b = \
                    scipy.signal.firwin(numtaps = filter_order,
                                    cutoff = self.cutoff_frequency * 2.0 / x.sampling_frequency,
                                    width = self.width,
                                    window = self.window)
            except TypeError:
                b = \
                    scipy.signal.firwin(N = filter_order-1,
                                    cutoff = self.cutoff_frequency * 2.0 / x.sampling_frequency,
                                    width = self.width,
                                    window = self.window)
            self.set_permanent_attributes(b=b)
        #Do the actual filtering
        filtered_data = numpy.zeros(x.shape)
        y = x.view(type=numpy.ndarray)
        for channel_index in selected_channel_indices:
            filtered_data[:,channel_index] = scipy.signal.convolve(self.b, \
                              y[:,channel_index])[len(self.b)/2:-len(self.b)/2+1]
        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #11
0
    def merge_time_series(self, input_collection):
        """ Merges all timeseries of the input_collection to one big timeseries """
        # Retriev the time series from the input_collection
        input_timeseries = input_collection.get_data(0,0,'test')
        # Get the data from the first timeseries
        output_data = input_timeseries[0][0]
        skiped_range = output_data.start_time

        # Change the endtime of the first timeseries to the one of the last
        # timeseries inside the input_collection
        input_timeseries[0][0].end_time = input_timeseries[-1][0].end_time
        # For all the remaining timeseries

        for ts in input_timeseries[1:]:
            # Concatenate the data...
            output_data = numpy.vstack((output_data,ts[0]))
            # ... and add the marker to the first timeseries
            if(len(ts[0].marker_name) > 0):
                for k in ts[0].marker_name:
                    if(not input_timeseries[0][0].marker_name.has_key(k)):
                        input_timeseries[0][0].marker_name[k] = []
                    for time in ts[0].marker_name[k]:
                        input_timeseries[0][0].marker_name[k].append(time+ts[0].start_time - skiped_range)
        # Use the meta information from the first timeseries e.g. marker start/end_time
        # and create a new timeseries with the concatenated data
        merged_time_series = TimeSeries.replace_data(input_timeseries[0][0],output_data)
        # Change the name of the merged_time_series
        merged_time_series.name = "%s, length %d ms, %s" % (merged_time_series.name.split(',')[0], \
                                                            (len(merged_time_series)*1000.0)/merged_time_series.sampling_frequency,\
                                                            merged_time_series.name.split(',')[-1])
        
        return merged_time_series
Exemple #12
0
    def _execute(self, x):
        """ Compute the energy of the given signal x using the TKEO """
        #Determine the indices of the channels which will be filtered
        #Done only once...
        if(self.selected_channel_indices == None):
            self.selected_channels = self.selected_channels \
            if self.selected_channels != None else x.channel_names
            self.selected_channel_indices = [x.channel_names.index(channel_name) \
                                            for channel_name in self.selected_channels]
            self.old_data = numpy.zeros((2,len(self.selected_channel_indices)))

        filtered_data = numpy.zeros(x.shape)
        channel_counter = -1
        for channel_index in self.selected_channel_indices:
            channel_counter += 1
            for i in range(len(x)):
                if i==0:
                    filtered_data[i][channel_index] = math.pow(self.old_data[1][channel_counter],2) - (self.old_data[0][channel_counter] * x[0][channel_index])
                elif i==1:
                    filtered_data[i][channel_index] = math.pow(x[0][channel_index],2) - (self.old_data[1][channel_counter] * x[1][channel_index])
                else:
                    filtered_data[i][channel_index] = math.pow(x[i-1][channel_index],2) - (x[i-2][channel_index] * x[i][channel_index])
            self.old_data[0][channel_counter] = x[-2][channel_index]
            self.old_data[1][channel_counter] = x[-1][channel_index]
        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #13
0
 def _execute(self, x):
     """
     f' = (f(x+h)-f(x))
     """
     if self.datapoints == None:
         self.datapoints = len(x)
     
     #create new channel names
     new_names = []
     for channel in range(len(x.channel_names)):
         new_names.append("%s'" %  (x.channel_names[channel]))
     #Derive the f' d2 from data x
     timeSeries = []
     for datapoint in range(self.datapoints):
         temp = []
         if((datapoint+1)<self.datapoints):
             for channel in range(len(x.channel_names)):
                 temp.append(x[datapoint+1][channel]-x[datapoint][channel])#*8*sampling_frequency
             timeSeries.append(temp)
     #padding with zero's if the original length of the time series have to remain equal.
     if self.keep_number_of_samples:
         temp = []
         for i in range(len(x.channel_names)):
             temp.append(0)
         timeSeries.append(temp)
     #Create a new time_series with the new data and channel names
     result_time_series = TimeSeries.replace_data(x, numpy.array(timeSeries))
     result_time_series.channel_names = new_names
     #if necessary adjust the length of the time series
     if not self.keep_number_of_samples:
         result_time_series.end_time -= 1
     
     return result_time_series
Exemple #14
0
    def _execute(self, data):
        """ Apply filter to data and return the result
        .. todo:: check if other view is needed here please
        """
        #Compute the FIR window which is required for the low pass filter, if it
        #not exists
        if self.filter_kernel is None:
            self.calc_filter_kernel(data)
            #Determine the indices of the channels which will be filtered
            self.selected_channel_names =  self.selected_channels \
                        if self.selected_channels != None else data.channel_names
            self.selected_channel_indices = \
                    [data.channel_names.index(channel_name) for channel_name in \
                                                     self.selected_channel_names]

        if self.comp_type == 'normal': #normal filtering with scipy

            filtered_data = numpy.zeros(data.shape)

            for channel_index in self.selected_channel_indices:
                filtered_data[:,channel_index] = \
                                      scipy.signal.lfilter(self.filter_kernel[0],
                                    self.filter_kernel[1], data[:,channel_index])

            result_time_series = TimeSeries.replace_data(data, filtered_data)

        elif self.comp_type == 'mirror':
            #filtering with scipy, mirror the data beforehand on the right border
            data_mirrored = numpy.vstack((data,numpy.flipud(data)))
            pre_filtered_data = numpy.zeros(data_mirrored.shape)
            for channel_index in self.selected_channel_indices:
                pre_filtered_data[:,channel_index] = \
                                      scipy.signal.lfilter(self.filter_kernel[0],
                           self.filter_kernel[1], data_mirrored[:,channel_index])

                pre_filtered_data[:,channel_index] = \
                                      scipy.signal.lfilter(self.filter_kernel[0],
                                                           self.filter_kernel[1],
                                numpy.flipud(pre_filtered_data[:,channel_index]))

            result_time_series = \
                     TimeSeries.replace_data(data, pre_filtered_data[:len(data)])

        else:
            raise ValueError("Computation type unknown")

        return result_time_series
Exemple #15
0
    def _execute(self, data):
        """ Apply filter to data and return the result
        .. todo:: check if other view is needed here please
        """
        #Compute the FIR window which is required for the low pass filter, if it
        #not exists
        if self.filter_kernel is None:
            self.calc_filter_kernel(data)
            #Determine the indices of the channels which will be filtered
            self.selected_channel_names =  self.selected_channels \
                        if self.selected_channels != None else data.channel_names
            self.selected_channel_indices = \
                    [data.channel_names.index(channel_name) for channel_name in \
                                                     self.selected_channel_names]

        if self.comp_type == 'normal':  #normal filtering with scipy

            filtered_data = numpy.zeros(data.shape)

            for channel_index in self.selected_channel_indices:
                filtered_data[:,channel_index] = \
                                      scipy.signal.lfilter(self.filter_kernel[0],
                                    self.filter_kernel[1], data[:,channel_index])

            result_time_series = TimeSeries.replace_data(data, filtered_data)

        elif self.comp_type == 'mirror':
            #filtering with scipy, mirror the data beforehand on the right border
            data_mirrored = numpy.vstack((data, numpy.flipud(data)))
            pre_filtered_data = numpy.zeros(data_mirrored.shape)
            for channel_index in self.selected_channel_indices:
                pre_filtered_data[:,channel_index] = \
                                      scipy.signal.lfilter(self.filter_kernel[0],
                           self.filter_kernel[1], data_mirrored[:,channel_index])

                pre_filtered_data[:,channel_index] = \
                                      scipy.signal.lfilter(self.filter_kernel[0],
                                                           self.filter_kernel[1],
                                numpy.flipud(pre_filtered_data[:,channel_index]))

            result_time_series = \
                     TimeSeries.replace_data(data, pre_filtered_data[:len(data)])

        else:
            raise ValueError("Computation type unknown")

        return result_time_series
Exemple #16
0
    def _execute(self, data):
        # Initialize the ringbuffers and variables one for each channel
        if(self.ringbuffer == None):
            self.width /= 1000.0
            self.width = int(self.width * data.sampling_frequency)
            self.nChannels = len(data.channel_names)
            self.ringbuffer = numpy.zeros((self.width,self.nChannels),dtype=numpy.double)
            self.variables = numpy.zeros((2,self.nChannels),dtype=numpy.double)
            self.index = numpy.zeros(self.nChannels,'i')

        # Convert the input data to double
        x = data.view(numpy.ndarray).astype(numpy.double)
        # Initialize the result data array
        filtered_data = numpy.zeros(x.shape)
        # Lists which are passed to the standadization
        # TODO: make self
        processing_filtered_data = None
        processing_ringbuffer = None
        processing_variables = None
        processing_index = None
        if(self.standardization):
            for channel_index in range(self.nChannels):
                # Copy the different data to the processing listst
                processing_filtered_data = numpy.array(filtered_data[:,channel_index],'d')
                processing_ringbuffer = numpy.array(self.ringbuffer[:,channel_index],'d')
                processing_variables = numpy.array(self.variables[:,channel_index],'d')
                processing_index = int(self.index[channel_index])
                if self.var_tools:
                    # Perform the standardization
                    # The module vt (variance_tools) is implemented in c using boost to wrap the code in python
                    # The module is located in trunk/library/variance_tools and have to be compiled
                    self.index[channel_index] = vt.standardization(processing_filtered_data, numpy.array(x[:,channel_index],'d'), processing_ringbuffer, processing_variables, self.width, processing_index)
                else:
                    self.index[channel_index] = self.standardisation(processing_filtered_data, numpy.array(x[:,channel_index],'d'), processing_ringbuffer, processing_variables, self.width, processing_index)
                # Copy the processing lists back to the local variables
                filtered_data[:,channel_index] = processing_filtered_data
                self.ringbuffer[:,channel_index] = processing_ringbuffer
                self.variables[:,channel_index] = processing_variables
        else:
            for channel_index in range(self.nChannels):
                # Copy the different data to the processing listst
                processing_filtered_data = numpy.array(filtered_data[:,channel_index],'d')
                processing_ringbuffer = numpy.array(self.ringbuffer[:,channel_index],'d')
                processing_variables = numpy.array(self.variables[:,channel_index],'d')
                processing_index = int(self.index[channel_index])
                if self.var_tools:
                    # Perform the filtering with the variance
                    # The module vt (variance_tools) is implemented in c using boost to wrap the code in python
                    # The module is located in trunk/library/variance_tools and have to be compiled
                    self.index[channel_index] = vt.filter(processing_filtered_data, numpy.array(x[:,channel_index],'d'), processing_ringbuffer, processing_variables, self.width, processing_index)
                else:
                    self.index[channel_index] = self.variance(processing_filtered_data, numpy.array(x[:,channel_index],'d'), processing_ringbuffer, processing_variables, self.width, processing_index)
                # Copy the processing lists back to the local variables
                filtered_data[:,channel_index] = processing_filtered_data
                self.ringbuffer[:,channel_index] = processing_ringbuffer
                self.variables[:,channel_index] = processing_variables
        # Return the result
        result_time_series = TimeSeries.replace_data(data, filtered_data)
        return result_time_series
Exemple #17
0
 def _execute(self, data):
     """ Subsample the given data and return a new time series """
     if self.new_len == 0 :
         self.new_len = int(round(self.target_frequency*len(data)/(1.0*data.sampling_frequency)))
     if not self.mirror:
         downsampled_time_series = \
             TimeSeries.replace_data(data, 
                                     scipy.signal.resample(data, self.new_len,
                                                         t=None, axis=0,
                                                         window=self.window))
     else:
         downsampled_time_series = \
             TimeSeries.replace_data(data, 
                                     scipy.signal.resample(numpy.vstack((data,numpy.flipud(data))), self.new_len*2,
                                                         t=None, axis=0,
                                                         window=self.window)[:self.new_len])
     downsampled_time_series.sampling_frequency = self.target_frequency
     return downsampled_time_series
Exemple #18
0
 def _execute(self, data):
     """ Apply the cast """
     #Determine the indices of the channels which will be filtered
     self._log("Cast data")
     casted_data = data.astype(self.datatype)
         
     result_time_series = TimeSeries.replace_data(data, casted_data)
     
     return result_time_series
Exemple #19
0
    def _execute(self, data):
        """ Apply the cast """
        #Determine the indices of the channels which will be filtered
        self._log("Cast data")
        casted_data = data.astype(self.datatype)

        result_time_series = TimeSeries.replace_data(data, casted_data)

        return result_time_series
Exemple #20
0
 def _execute(self, data):
     """ Subsample the given data and return a new time series """
     if self.new_len == 0 :
         self.new_len = int(round(self.target_frequency*len(data)/(1.0*data.sampling_frequency)))
     if not self.mirror:
         downsampled_time_series = \
             TimeSeries.replace_data(data, 
                                     scipy.signal.resample(data, self.new_len,
                                                         t=None, axis=0,
                                                         window=self.window))
     else:
         downsampled_time_series = \
             TimeSeries.replace_data(data, 
                                     scipy.signal.resample(numpy.vstack((data,numpy.flipud(data))), self.new_len*2,
                                                         t=None, axis=0,
                                                         window=self.window)[:self.new_len])
     downsampled_time_series.sampling_frequency = self.target_frequency
     return downsampled_time_series
Exemple #21
0
 def _execute(self, x):
     """
     Apply z-score transformation to the given data and return a modified
     time series.
     """
     data = x.view(numpy.ndarray)
     #Do the z-score transformation
     std = numpy.std(data-numpy.mean(data, axis=0), axis=0)
     std = check_zero_division(self, std,  tolerance=10**-15, data_ts=x)
     return TimeSeries.replace_data(x, (data-numpy.mean(data, axis=0)) / std)
Exemple #22
0
    def _execute(self, x):
        data = x.view(numpy.ndarray)
        mean = numpy.mean(data, axis=0)
        data -= mean

        max_values = numpy.abs(numpy.max(data, axis=0))

        max_values = check_zero_division(self, max_values, tolerance=10**-15,
                                         data_ts=x)

        return TimeSeries.replace_data(x, data/max_values)
Exemple #23
0
    def _execute(self, data):
        """
        Apply the scaling to the given data x
        and return a new time series.
        """
        x = data.view(numpy.ndarray).astype(numpy.double)
        x = x * self.factor

        result_time_series = TimeSeries.replace_data(data, x)

        return result_time_series
    def _execute(self, data):
        """ Reorder the memory. """

        # exchange data of time series object to correctly ordered data
        buffer = numpy.array(data, order='F')

        if self.convert_type and numpy.dtype('float64') != buffer.dtype:
            buffer = buffer.astype(numpy.float)
        
        data = TimeSeries.replace_data(data,buffer)
        
        return data
Exemple #25
0
    def _execute(self, data):
        """
        Apply the scaling to the given data x
        and return a new time series.
        """
        x = data.view(numpy.ndarray)

        x.clip(self.min_threshold, self.max_threshold, out = x)

        result_time_series = TimeSeries.replace_data(data, x)

        return result_time_series
Exemple #26
0
    def _execute(self, data):
        """ Reorder the memory. """

        # exchange data of time series object to correctly ordered data
        buffer = numpy.array(data, order='F')

        if self.convert_type and numpy.dtype('float64') != buffer.dtype:
            buffer = buffer.astype(numpy.float)

        data = TimeSeries.replace_data(data, buffer)

        return data
Exemple #27
0
    def _execute(self, data):
        # First check if all channels actually appear in the data

        # Determine the indices of the channels that are the basis for the
        # average reference.
        if not self.inverse:
            if self.avg_channels == None:
                self.avg_channels = data.channel_names
            channel_indices = [
                data.channel_names.index(channel_name)
                for channel_name in self.avg_channels
            ]
        else:
            channel_indices = [
                data.channel_names.index(channel_name)
                for channel_name in data.channel_names
                if channel_name not in self.avg_channels
            ]

        not_found_channels = \
            [channel_name for channel_name in self.avg_channels
                     if channel_name not in data.channel_names]
        if not not_found_channels == []:
            warnings.warn(
                "Couldn't find selected channel(s): %s. Ignoring." %
                not_found_channels, Warning)

        if self.old_ref is None:
            self.old_ref = 'avg'

        # Compute the actual data of the reference channel. This is the sum of all
        # channels divided by (the number of channels +1).
        ref_chen = -numpy.sum(data[:, channel_indices], axis=1) / (
            data.shape[1] + 1)
        ref_chen = numpy.atleast_2d(ref_chen).T
        # Reference all electrodes against average
        avg_referenced_data = data + ref_chen

        # Add average as new channel to the signal if enabled
        if self.keep_average:
            avg_referenced_data = numpy.hstack((avg_referenced_data, ref_chen))
            channel_names = data.channel_names + [self.old_ref]
            result_time_series = TimeSeries(avg_referenced_data, channel_names,
                                            data.sampling_frequency,
                                            data.start_time, data.end_time,
                                            data.name, data.marker_name)
        else:
            result_time_series = TimeSeries.replace_data(
                data, avg_referenced_data)

        return result_time_series
Exemple #28
0
 def test_repalce_data(self):
     data = TimeSeries.replace_data(
         self.x2, [10, 11, 12, 13, 14, 15],
         channel_names=['m', 'n', 'o', 'p', 'q', 'r'],
         sampling_frequency=30,
         start_time=1200.0)
     self.assertFalse(
         (data.view(np.ndarray) - [10, 11, 12, 13, 14, 15]).any())
     self.assertEqual(data.channel_names, ['m', 'n', 'o', 'p', 'q', 'r'])
     self.assertEqual(data.sampling_frequency, 30)
     self.assertEqual(data.start_time, 1200)
     self.assertEqual(data.end_time, 13004)
     self.assertEqual(data.name, 'Name_text ending with Standard')
     self.assertEqual(data.tag, 'Tag of x2')
Exemple #29
0
    def _execute(self, x):
        """
        Apply devariancing to the given data and return the modified time series
        """
        #Determine the indices of the channels which will be filtered
        selected_channel_indices = [x.channel_names.index(channel_name)
                                      for channel_name in self.selected_channels]

        #Do the actual devariancing, i.e. multiply with the scale factor
        devarianced_data = numpy.zeros(x.shape)
        for channel in self.selected_channels:
            channel_index = x.channel_names.index(channel)
            devarianced_data[:, channel_index] = x[:, channel_index] * \
                                                      self.scale_factors[channel]

        return TimeSeries.replace_data(x, devarianced_data)
Exemple #30
0
    def _execute(self, data):
        # First check if all channels actually appear in the data

        # Determine the indices of the channels that are the basis for the 
        # average reference.
        if not self.inverse:
            if self.avg_channels == None:
                self.avg_channels = data.channel_names
            channel_indices = [data.channel_names.index(channel_name) 
                                for channel_name in self.avg_channels]
        else:
            channel_indices = [data.channel_names.index(channel_name)
                               for channel_name in data.channel_names
                               if channel_name not in self.avg_channels]

        not_found_channels = \
            [channel_name for channel_name in self.avg_channels 
                     if channel_name not in data.channel_names]
        if not not_found_channels == []:
            warnings.warn("Couldn't find selected channel(s): %s. Ignoring." % 
                            not_found_channels, Warning)
                    
        if self.old_ref is None:
            self.old_ref = 'avg'
        
        # Compute the actual data of the reference channel. This is the sum of all 
        # channels divided by (the number of channels +1).
        ref_chen = -numpy.sum(data[:, channel_indices], axis=1)/(data.shape[1]+1)
        ref_chen = numpy.atleast_2d(ref_chen).T
        # Reference all electrodes against average
        avg_referenced_data = data + ref_chen
        
        # Add average as new channel to the signal if enabled
        if self.keep_average:
            avg_referenced_data = numpy.hstack((avg_referenced_data, ref_chen))
            channel_names = data.channel_names + [self.old_ref]
            result_time_series = TimeSeries(avg_referenced_data, 
                                            channel_names,
                                            data.sampling_frequency, 
                                            data.start_time, data.end_time,
                                            data.name, data.marker_name)
        else:
            result_time_series = TimeSeries.replace_data(data, 
                                                            avg_referenced_data)
        
        return result_time_series
Exemple #31
0
    def _execute(self, x):
        """
        Apply memory z-score transformation to the given data
        and return a new time series.
        """
        data = x.view(numpy.ndarray)
        # calculate the important measures in an array format
        mean = numpy.mean(data, axis=0)
        var = numpy.var(data, axis=0)

        # initialize the memory when it is first used
        if self.memory is None:
            self.memory = dict()
            self.memory['mean'] = list()
            self.memory['var'] = list()
            for i in range(self.order):
                self.memory['mean'].append(mean)
                self.memory['var'].append(var)

        # extend the memory by the new mean and variance if the
        # std<200 and not zero to exclude big artifacts
        if (var < 40000).all() and (var > 10**-9).all():
            self.memory['var'].append(var)
            self.memory['mean'].append(mean)

            # calculate the mean of the current mean and variance
            # and the latest (order) means and variances in memory
            # and delete the last, because it is no longer needed
            var = numpy.mean(self.memory['var'], axis=0)
            mean = numpy.mean(self.memory['mean'], axis=0)
            self.memory['var'].pop(0)
            self.memory['mean'].pop(0)
        std = numpy.sqrt(var)

        # # code for easy viszualization
        # statistic = numpy.vstack((mean,std))
        # statistic = TimeSeries.replace_data(data, statistic)
        # statistic.sampling_frequency = 1
        # return statistic

        #Do the modified z-score transformation
        std = check_zero_division(self, std, tolerance=10**-15, data_ts=x)

        return TimeSeries.replace_data(x,
                                       (data - numpy.mean(data, axis=0)) / std)
Exemple #32
0
    def _execute(self, x):
        """ Executes the preprocessing on the given data vector x"""
        #Number of retained channels
        num_channels = numpy.size(x, 1)
        if (self.below_threshold == None):
            # When the node is called for the first time initialize all parameters/variables
            self.width_AT = int((self.width_AT * x.sampling_frequency) / 1000.)

            #Convert the time from ms to samples
            self.time_below_threshold = int(
                (self.time_below_threshold * x.sampling_frequency) / 1000.)

            #Create and prefill the array which indicates how long a signal was below the threshold
            self.below_threshold = numpy.zeros(num_channels)
            self.below_threshold.fill(self.time_below_threshold + 1)

            #Create the ringbuffer and the variables list for the adaptive threshold
            self.ringbuffer_AT = numpy.zeros((self.width_AT, num_channels))
            self.variables_AT = numpy.zeros((4, num_channels))
        data = x.view(numpy.ndarray)
        #Create the array for the thresholded data
        threshold_data = numpy.zeros(data.shape)
        #For each sample of each retained channel
        for i in range(num_channels):
            data_index = 0
            for sample in data[:, i]:
                #calculate the adaptive threshold
                value = self.adaptive_threshold(sample, i)
                #if the actual sample exceeds the threshold...
                if (sample >= value):
                    #and the resting time was observed
                    if (self.below_threshold[i] > self.time_below_threshold):
                        #store a 1 indicating a onset
                        threshold_data[data_index][i] = 1
                    #reset the resting time counter
                    self.below_threshold[i] = 0
                #increase the time the signal was below the signal
                else:
                    self.below_threshold[i] += 1
                data_index += 1

        #return the thresholded data
        result_time_series = TimeSeries.replace_data(x, threshold_data)
        return result_time_series
    def _execute(self, x):
        """
        Apply memory z-score transformation to the given data
        and return a new time series.
        """
        data = x.view(numpy.ndarray)
        # calculate the important measures in an array format
        mean = numpy.mean(data, axis=0)
        var = numpy.var(data, axis=0)

        # initialize the memory when it is first used
        if self.memory is None:
            self.memory=dict()
            self.memory['mean'] = list()
            self.memory['var'] = list()
            for i in range(self.order):
                self.memory['mean'].append(mean)
                self.memory['var'].append(var)

        # extend the memory by the new mean and variance if the
        # std<200 and not zero to exclude big artifacts
        if (var < 40000).all() and (var > 10**-9).all():
            self.memory['var'].append(var)
            self.memory['mean'].append(mean)

        # calculate the mean of the current mean and variance
        # and the latest (order) means and variances in memory
        # and delete the last, because it is no longer needed
            var = numpy.mean(self.memory['var'],axis=0)
            mean = numpy.mean(self.memory['mean'],axis=0)
            self.memory['var'].pop(0)
            self.memory['mean'].pop(0)
        std = numpy.sqrt(var)

        # # code for easy viszualization
        # statistic = numpy.vstack((mean,std))
        # statistic = TimeSeries.replace_data(data, statistic)
        # statistic.sampling_frequency = 1
        # return statistic

        #Do the modified z-score transformation
        std = check_zero_division(self, std,  tolerance=10**-15, data_ts=x)

        return TimeSeries.replace_data(x, (data-numpy.mean(data, axis=0))/std)
    def _execute(self, x):
        """ Executes the preprocessing on the given data vector x"""
        #Number of retained channels
        num_channels = numpy.size(x,1)
        if(self.below_threshold == None):
            # When the node is called for the first time initialize all parameters/variables
            self.width_AT = int((self.width_AT*x.sampling_frequency)/1000.)
            
            #Convert the time from ms to samples
            self.time_below_threshold = int((self.time_below_threshold*x.sampling_frequency)/1000.)
            
            #Create and prefill the array which indicates how long a signal was below the threshold
            self.below_threshold = numpy.zeros(num_channels)
            self.below_threshold.fill(self.time_below_threshold+1)
            
            #Create the ringbuffer and the variables list for the adaptive threshold 
            self.ringbuffer_AT=numpy.zeros((self.width_AT,num_channels))
            self.variables_AT=numpy.zeros((4,num_channels))
        data=x.view(numpy.ndarray)
        #Create the array for the thresholded data
        threshold_data = numpy.zeros(data.shape)
        #For each sample of each retained channel
        for i in range(num_channels):
            data_index = 0
            for sample in data[:,i]:
                #calculate the adaptive threshold
                value = self.adaptive_threshold(sample, i)
                #if the actual sample exceeds the threshold...
                if(sample >= value):
                    #and the resting time was observed
                    if(self.below_threshold[i] > self.time_below_threshold):
                        #store a 1 indicating a onset
                        threshold_data[data_index][i] = 1
                    #reset the resting time counter
                    self.below_threshold[i] = 0
                #increase the time the signal was below the signal
                else:
                    self.below_threshold[i] += 1
                data_index += 1

        #return the thresholded data
        result_time_series = TimeSeries.replace_data(x, threshold_data)
        return result_time_series
    def _train(self, data):
        """ Check which channels have constant values.

        The training data is considered and the invalid channel names
        are removed. The first data entry is saved and the starting
        assumption is that all channels have constant values. When a value
        different from the first data entry for a respective channel is found,
        that channel is removed from the list of channels that have constant
        values.
        """
        # copy the first data value
        if self.data_values is None:
            # copy the first entry
            self.data_values = TimeSeries.replace_data(data, data.get_data()[0])
            # invalidate all the channels in the beginning
            self.selected_channel_names = copy.deepcopy(data.channel_names)

        for channel in self.selected_channel_names:
            if (data.get_channel(channel) != self.data_values.get_channel(channel)[0]).any():
                self.selected_channel_names.remove(channel)
Exemple #36
0
    def _execute(self, data):
        """ Apply the detrending method to the given data x and return a new time series """
        #Determine the indices of the channels which will be filtered
        x = data.view(numpy.ndarray)
        if self.selected_channel_indices is None:
            self.selected_channel_names = self.selected_channels \
                if not self.selected_channels is None else data.channel_names
            self.selected_channel_indices = \
                    [data.channel_names.index(channel_name)
                     for channel_name in self.selected_channel_names]

        #Do the actual detrending
        detrended_data = numpy.zeros(x.shape)
        for channel_index in self.selected_channel_indices:
            detrended_data[:, channel_index] = \
                self.detrend_method(x[:, channel_index])

        result_time_series = TimeSeries.replace_data(data, detrended_data)

        return result_time_series
Exemple #37
0
    def _execute(self, x):
        """
        Apply the detrending method to the given data x
        and return a new time series.
        """
        #Determine the indices of the channels which will be filtered
        if None == self.selected_channel_indices:
            self.selected_channel_names = self.selected_channels \
                          if self.selected_channels != None else x.channel_names
            self.selected_channel_indices = \
                    [x.channel_names.index(channel_name) for channel_name in \
                                                    self.selected_channel_names]
        #Do the actual detrending
        detrended_data = numpy.zeros(x.shape)
        for channel_index in self.selected_channel_indices:
            temp = x[:, channel_index]
            temp = temp*numpy.float64(1)/numpy.linalg.norm(temp)
            detrended_data[:, channel_index] = temp
        result_time_series = TimeSeries.replace_data(x, detrended_data)

        return result_time_series
Exemple #38
0
    def _execute(self, data):
        """
        Exchanges the data with some manually generated data.
        """

        if self.generator is None:
            self.generator = eval(self.generator_expression)

        self.data_item = \
            self.ts_generator.generate_test_data(
                channels=data.shape[1],
                time_points=data.shape[0],
                function=self.generator,
                sampling_frequency=data.sampling_frequency,
                channel_order=True,
                channel_names=data.channel_names,
                dtype=numpy.float)

        result_time_series = TimeSeries.replace_data(data, self.data_item)

        return result_time_series
    def _execute(self, data):
        """
        Exchanges the data with some manually generated data.
        """

        if self.generator is None:
            self.generator = eval(self.generator_expression)

        self.data_item = \
            self.ts_generator.generate_test_data(
                channels=data.shape[1],
                time_points=data.shape[0],
                function=self.generator,
                sampling_frequency=data.sampling_frequency,
                channel_order=True,
                channel_names=data.channel_names,
                dtype=numpy.float)

        result_time_series = TimeSeries.replace_data(data, self.data_item)


        return result_time_series
Exemple #40
0
    def _train(self, data):
        """ Check which channels have constant values.

        The training data is considered and the invalid channel names
        are removed. The first data entry is saved and the starting
        assumption is that all channels have constant values. When a value
        different from the first data entry for a respective channel is found,
        that channel is removed from the list of channels that have constant
        values.
        """
        # copy the first data value
        if self.data_values is None:
            # copy the first entry
            self.data_values = TimeSeries.replace_data(data,
                                                       data.get_data()[0])
            # invalidate all the channels in the beginning
            self.selected_channel_names = copy.deepcopy(data.channel_names)

        for channel in self.selected_channel_names:
            if (data.get_channel(channel) !=
                    self.data_values.get_channel(channel)[0]).any():
                self.selected_channel_names.remove(channel)
Exemple #41
0
    def _execute(self, data):
        """ Subsample the given data data and return a new time series """
        # Compute the downsampling factor
        source_frequency = int(round(data.sampling_frequency * 100))
        target_frequency = int(round(self.target_frequency * 100))
        reduce_fraction_factor = gcd(source_frequency, target_frequency)
        new_downsampling_factor = source_frequency / reduce_fraction_factor

        upsampling_factor = target_frequency / reduce_fraction_factor
        if not (upsampling_factor == 1):
            self._log("Upsampling used but not implemented!" +
                      " Check target frequency and real frequency!",
                      level=logging.WARNING)

        # reset filter if downsampling factor has changed
        if new_downsampling_factor != self.downsampling_factor:
            self.downsampling_factor = new_downsampling_factor

            if self.downsampling_factor <= 1:
                self._log("Inapplicable downsampling factor: " +
                          str(self.downsampling_factor) +
                          " Downsampling will be skipped",
                          level=logging.WARNING)

        # omit downsampling, if inapplicable
        if self.downsampling_factor <= 1:
            return data

        # Downsampling (can be achieved by a simple re-striding)
        # Note: We have to create a new array since otherwise the off-strided
        #       data remains in memory
        downsampled_data = numpy.array(data[::self.downsampling_factor, :])
        downsampled_time_series = TimeSeries.replace_data(
            data, downsampled_data)
        downsampled_time_series.sampling_frequency = self.target_frequency

        return downsampled_time_series
Exemple #42
0
    def _execute(self, x):
        """ Apply band pass filter to data x and return the result """
        #Determine the indices of the channels which will be filtered
        selected_channel_names = self.selected_channels \
                           if self.selected_channels != None else x.channel_names
        selected_channel_indices = [x.channel_names.index(channel_name) \
                                      for channel_name in selected_channel_names]

        #Do the actual filtering
        x_data = x.view(
            numpy.ndarray)  # More efficient slicing, without memory copy...
        filtered_data = numpy.zeros(x.shape)
        for channel_index in selected_channel_indices:
            #Fourier transform
            fourier_transformed = scipy.fftpack.fft(x_data[:, channel_index])

            #Compute the pass band indices
            lower_bound = int(round(float(self.pass_band[0]) / \
                                x.sampling_frequency * len(fourier_transformed)))
            upper_bound = int(round(float(self.pass_band[1]) / \
                                x.sampling_frequency * len(fourier_transformed)))

            #Setting frequencies outside the pass band to 0
            for i in range(0, lower_bound):
                fourier_transformed[i] = 0
                fourier_transformed[-i - 1] = 0
            for i in range(upper_bound, len(fourier_transformed) / 2):
                fourier_transformed[i] = 0
                fourier_transformed[-i - 1] = 0

            #Inverse Fourier transform and project to real component
            filtered_data[:, channel_index] = \
                                      scipy.fftpack.ifft(fourier_transformed).real

        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #43
0
    def _execute(self, x):
        """ Apply band pass filter to data x and return the result """
        #Determine the indices of the channels which will be filtered
        selected_channel_names = self.selected_channels \
                           if self.selected_channels != None else x.channel_names
        selected_channel_indices = [x.channel_names.index(channel_name) \
                                      for channel_name in selected_channel_names]


        #Do the actual filtering
        x_data=x.view(numpy.ndarray) # More efficient slicing, without memory copy...
        filtered_data = numpy.zeros(x.shape)
        for channel_index in selected_channel_indices:
            #Fourier transform
            fourier_transformed = scipy.fftpack.fft(x_data[:, channel_index])

            #Compute the pass band indices
            lower_bound = int(round(float(self.pass_band[0]) / \
                                x.sampling_frequency * len(fourier_transformed)))
            upper_bound = int(round(float(self.pass_band[1]) / \
                                x.sampling_frequency * len(fourier_transformed)))

            #Setting frequencies outside the pass band to 0
            for i in range(0, lower_bound):
                fourier_transformed[i] = 0
                fourier_transformed[-i-1] = 0
            for i in range(upper_bound,len(fourier_transformed)/2):
                fourier_transformed[i] = 0
                fourier_transformed[-i-1] = 0

            #Inverse Fourier transform and project to real component
            filtered_data[:, channel_index] = \
                                      scipy.fftpack.ifft(fourier_transformed).real

        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #44
0
    def _execute(self, x):
        """ Apply high pass filter to data x and return the result """

        #Determine the indices of the channels which will be filtered
        selected_channel_names =  self.selected_channels \
                            if self.selected_channels != None else x.channel_names
        selected_channel_indices = [x.channel_names.index(channel_name) \
                                       for channel_name in selected_channel_names]
        if self.b is None:
            #Compute the FIR window which is required for the high pass filter
            try:
                b = scipy.signal.firwin(numtaps=self.taps,
                                        cutoff=self.cutoff_frequency * 2.0 /
                                        x.sampling_frequency,
                                        width=self.width,
                                        window=self.window)
            except TypeError:
                b = scipy.signal.firwin(N=self.taps - 1,
                                        cutoff=self.cutoff_frequency * 2.0 /
                                        x.sampling_frequency,
                                        width=self.width,
                                        window=self.window)
            b = -b
            b[self.taps / 2] = b[self.taps / 2] + 1
            self.set_permanent_attributes(b=b)

        #Do the actual filtering
        y = x.view(numpy.ndarray)
        filtered_data = numpy.zeros(x.shape)
        for channel_index in selected_channel_indices:
            filtered_data[:,channel_index] = \
                                  scipy.signal.lfilter(self.b, [1], y[:,channel_index])

        result_time_series = TimeSeries.replace_data(x, filtered_data)

        return result_time_series
Exemple #45
0
    def _execute(self, data):
        """ Subsample the given data data and return a new time series """
        # Compute the downsampling factor
        source_frequency = int(round(data.sampling_frequency * 100))
        target_frequency = int(round(self.target_frequency * 100))
        reduce_fraction_factor = gcd(source_frequency, target_frequency)
        new_downsampling_factor = source_frequency /reduce_fraction_factor
        
        upsampling_factor = target_frequency / reduce_fraction_factor
        if not(upsampling_factor == 1):
            self._log("Upsampling used but not implemented!"
                      +" Check target frequency and real frequency!",
                      level=logging.WARNING)
        
        # reset filter if downsampling factor has changed
        if new_downsampling_factor != self.downsampling_factor:
            self.downsampling_factor = new_downsampling_factor

            if self.downsampling_factor <= 1:
                self._log("Inapplicable downsampling factor: "
                          + str(self.downsampling_factor)
                          +" Downsampling will be skipped",
                          level=logging.WARNING)

        # omit downsampling, if inapplicable
        if self.downsampling_factor <= 1:
            return data
                        
        # Downsampling (can be achieved by a simple re-striding)
        # Note: We have to create a new array since otherwise the off-strided 
        #       data remains in memory
        downsampled_data = numpy.array(data[::self.downsampling_factor, :])
        downsampled_time_series = TimeSeries.replace_data(data, downsampled_data) 
        downsampled_time_series.sampling_frequency = self.target_frequency
                
        return downsampled_time_series
Exemple #46
0
    def _execute(self, x):
        """ Subsample the given data x and return a new time series """
        # Compute the upsampling and downsampling factor
        source_frequency = int(round(x.sampling_frequency * 100))
        target_frequency = int(round(self.target_frequency * 100))
        reduce_fraction_factor = gcd(source_frequency, target_frequency)
        upsampling_factor = target_frequency / reduce_fraction_factor
        downsampling_factor = source_frequency /reduce_fraction_factor
        # Upsampling
        if upsampling_factor == 1:
            upsampled_time_series = x
        else:
            # We make a linear interpolation for upsampling as an easy version.
            # This should be enough because of the following Lowpassfilter.
            # It is maybe a better version to construction a C^1 spline, 
            # because it prevents artifacts in frequency, but this would  
            # decrease processing speed significantly.
            
            # The new Data Array for the upsampled data
            # The last timepoint does not bring additional points. 
            # This results in the -1+1 calculation.
            self._log("Using upsampling.", level=logging.WARNING)
            
            interpolated_time_series = numpy.zeros((upsampling_factor*(len(x)-1)+1,
                                                       len(x.channel_names)))

            # Array that corresponds to the x value of the fictive function 
            # (original data)
            time = linspace(0, len(x)-1, len(x))
            # Array that corresponds to the x value of the fictive function 
            # (upsampled data)
            newTime = linspace(0, len(x)-1, len(interpolated_time_series))
            # Linear interpolation of each channel
            for channel_name in x.channel_names:
                channel_index = x.channel_names.index(channel_name)
                f = interp1d(time, x[:,channel_index])
                interpolated_time_series[:,channel_index] = f(newTime)
            upsampled_time_series = TimeSeries.replace_data(x,
                                                            interpolated_time_series)
                        
        # Low Pass filtering: According to Shannon-Nyquist's sampling theorem, 
        # we should only retain frequency components below 1/2*target_frequency
        # We multiply with 0.45 instead of 0.5 because of the finite window 
        # length
        lpf_node = filtering.SimpleLowPassFilterNode(cutoff_frequency =  self.target_frequency * 0.45)
        filtered_time_series = lpf_node.execute(upsampled_time_series)
        
        # Downsampling (can be achieved by a simple re-striding)
        # Note: We have to create a new array since otherwise the off-strided 
        #       data remains in memory
        downsampled_data = numpy.array(filtered_time_series[::downsampling_factor, :])
        downsampled_time_series = TimeSeries.replace_data(x, downsampled_data) 
        downsampled_time_series.sampling_frequency = self.target_frequency
        
#        # Uncomment for graphical analyzation
#        import pylab
#        pylab.figure(1)
#        pylab.plot(pylab.linspace(0.0, 1.0, x.shape[0]),
#                   x[:,x.channel_names.index('Pz')],
#                   label = 'Pz' + "_subsampled")
#        pylab.figure(2)
#        pylab.subplot(312)
#        pylab.specgram(x[:,x.channel_names.index('Pz')], Fs = x.sampling_frequency,
#                       NFFT = 64, noverlap = 63)
#        pylab.colorbar()
#        pylab.show()

        return downsampled_time_series
Exemple #47
0
    def _prepare_prediction(self,
                            data):  #PredictionVector    Data to work with.
        """ Convert prediction vector to time series object for visualization

        Using the function *get_previous_transformations* the node history is
        searched for the respective transformation parametrizations and then
        the transformations are combined tog et a complete picture of the
        data processing chain.

        A special case is, when the
        :class:`~pySPACE.missions.nodes.meta.flow_node.BacktransformationNode`


        **Parameters**

            :data: This is a Prediction Vector, which might contain data in its
                   history component which is used for multiplication with
                   the transformation or which is used as sample for
                   calculating the derivative of the processing chain for the
                   backtransformation.
        """
        if self.current_trafo_TS is None:  #needed only once
            transformation_list = self.get_previous_transformations(data)
            classifier = transformation_list[-1]
            if classifier[3] == "generic_backtransformation":
                current_trafo = classifier[0]
                if type(current_trafo) == FeatureVector:
                    current_trafo_TS = type_conversion.\
                        FeatureVector2TimeSeriesNode()._execute(current_trafo)
                elif type(current_trafo) == TimeSeries:
                    current_trafo_TS = current_trafo
                if self.covariancing:
                    shape = current_trafo_TS.shape
                    covariance = classifier[1][1]
                    new_TS_array = numpy.dot(
                        covariance, current_trafo_TS.flatten()).reshape(shape)
                    current_trafo_TS = TimeSeries.replace_data(
                        current_trafo_TS, new_TS_array)
            elif classifier[3] == "linear classifier":
                classifier_FV = FeatureVector(numpy.atleast_2d(classifier[0]),
                                              feature_names=classifier[2])
                current_trafo = classifier_FV
                if self.use_FN:
                    try:
                        FN = transformation_list[-2]
                        assert (FN[3] == "feature normalization")
                        assert (
                            classifier[2] == FN[2]
                        ), "VisualizationBase:: Feature names do not match!"
                        FN_FV = FeatureVector(numpy.atleast_2d(FN[0]),
                                              feature_names=FN[2])
                        current_trafo = FeatureVector(
                            current_trafo * FN_FV,
                            feature_names=FN_FV.feature_names)
                    except:
                        warnings.warn(
                            "VisualizationBase:: Did not get any feature normalization!"
                        )
                        pass  #raise
                current_trafo_TS = type_conversion.FeatureVector2TimeSeriesNode(
                )._execute(current_trafo)
                if self.use_SF:
                    try:
                        # TODO CHECK fitting of channel names
                        SF = transformation_list[-2]
                        if not SF[3] == "spatial filter":
                            SF = transformation_list[-3]
                        assert (SF[3] == "spatial filter")
                        new_channel_names = SF[2]
                        SF_trafo = SF[0]
                        current_trafo_TS = TimeSeries(
                            numpy.dot(current_trafo_TS, SF_trafo.T),
                            channel_names=new_channel_names,
                            sampling_frequency=current_trafo_TS.
                            sampling_frequency)
                    except:
                        warnings.warn(
                            "VisualizationBase:: Did not get any spatial filter!"
                        )
                        pass  #raise
            else:
                warnings.warn("VisualizationBase:: " +
                              "Did not get any classifier transformation!")
                raise RuntimeError
            # the reordering should have been done in the type conversion
            current_trafo_TS.reorder(sorted(current_trafo_TS.channel_names))
            self.current_trafo_TS = current_trafo_TS
        prepared_prediction = self.current_trafo_TS

        if self.history_index:
            found_in_history = False
            if data.has_history():
                try:
                    prepared_history = copy.deepcopy(
                        data.history[self.history_index - 1])
                    if type(prepared_history) == FeatureVector:
                        prepared_history = type_conversion.FeatureVector2TimeSeriesNode(
                        )._execute(prepared_history)
                    found_in_history = True
                except:
                    pass
            if found_in_history:
                prepared_history.reorder(self.current_trafo_TS.channel_names)
                prepared_prediction = copy.deepcopy(
                    prepared_prediction) * prepared_history
            else:
                warnings.warn(
                    "VisualizationBase:: No FeatureVector or TimeSeries found in history. Parameter history_index ignored!"
                )

        return prepared_prediction
Exemple #48
0
    def central_difference_with_halfstep_method(self, sample):
        """ implementation of the central difference method with a half step

        **Principle**

        The principle applied by the central difference method with a half step is

        .. math::

            f'(x)=\\frac{f(x-h)-8f(x-\\frac{h}{2})+8f(x+\\frac{h}{2})-f(x-h)}{6h}

        where :math:`h` is the step of the differentiation that is computed
        as :math:`h(x)=\sqrt{\\varepsilon} \\cdot x` for :math:`x \\neq 0` and
        :math:`h(0)=\\sqrt{\\varepsilon}` for :math:`x=0`.

        **Parameters**

            :sample:
                the initial value used for the derivation

        .. note::

            This method is the most accurate differentiation method but also
            has the greatest overhead.
        """
        if type(sample) == FeatureVector:
            self.trafo = FeatureVector.replace_data(
                    self.example, numpy.zeros(self.example.shape))
            for j in range(len(sample.feature_names)):
                positive_offset = copy.deepcopy(sample)
                negative_offset = copy.deepcopy(sample)
                half_positive_offset = copy.deepcopy(sample)
                half_negative_offset = copy.deepcopy(sample)

                if positive_offset[0][j] == 0.:
                    diff = numpy.sqrt(self.eps)
                else:
                    diff = numpy.sqrt(self.eps)*positive_offset[0][j]
                positive_offset[0][j] += diff
                negative_offset[0][j] -= diff
                half_positive_offset[0][j] += diff/2.
                half_negative_offset[0][j] -= diff/2.
                
                diff = (positive_offset[0][j]-negative_offset[0][j])/2.

                positive_vector = FeatureVector.replace_data(
                    sample,
                    positive_offset
                )
                negative_vector = FeatureVector.replace_data(
                    sample,
                    negative_offset
                )
                half_positive_vector = FeatureVector.replace_data(
                    sample,
                    half_positive_offset
                )
                half_negative_vector = FeatureVector.replace_data(
                    sample,
                    half_negative_offset
                )
                self.trafo[0][j] = \
                    numpy.longdouble((self._execute(negative_vector) -
                                    8*self._execute(half_negative_vector) +
                                    8*self._execute(half_positive_vector) -
                                    self._execute(positive_vector))/(6.*diff))
        elif type(sample) == TimeSeries:
            self.trafo = TimeSeries.replace_data(
                self.example, numpy.zeros(self.example.shape))
            for i in range(sample.shape[0]):
                for j in range(sample.shape[1]):
                    positive_offset = copy.deepcopy(sample)
                    negative_offset = copy.deepcopy(sample)
                    half_positive_offset = copy.deepcopy(sample)
                    half_negative_offset = copy.deepcopy(sample)

                    if positive_offset[i][j] == 0.:
                        diff = numpy.sqrt(self.eps)
                    else:
                        diff = numpy.sqrt(self.eps)*positive_offset[i][j]
                    positive_offset[i][j] += diff
                    negative_offset[i][j] -= diff
                    half_positive_offset[i][j] += diff/2.
                    half_negative_offset[i][j] -= diff/2.
                    
                    diff = (positive_offset[i][j]-negative_offset[i][j])/2.

                    positive_series = TimeSeries.replace_data(
                        sample,
                        positive_offset
                    )
                    negative_series = TimeSeries.replace_data(
                        sample,
                        negative_offset
                    )
                    half_positive_series = TimeSeries.replace_data(
                        sample,
                        half_positive_offset
                    )
                    half_negative_series = TimeSeries.replace_data(
                        sample,
                        half_negative_offset
                    )
                    self.trafo[i][j] = \
                        numpy.longdouble((self._execute(negative_series) -
                                        8*self._execute(half_negative_series) +
                                        8*self._execute(half_positive_series) -
                                        self._execute(positive_series))/(6.*diff))
Exemple #49
0
    def _execute(self, data):
        # Initialize the ringbuffers and variables one for each channel
        if (self.ringbuffer == None):
            self.width /= 1000.0
            self.width = int(self.width * data.sampling_frequency)
            self.nChannels = len(data.channel_names)
            self.ringbuffer = numpy.zeros((self.width, self.nChannels),
                                          dtype=numpy.double)
            self.variables = numpy.zeros((2, self.nChannels),
                                         dtype=numpy.double)
            self.index = numpy.zeros(self.nChannels, 'i')
        if (self.width <= 1):
            warnings.warn(
                "Width have to be greater than 1!\nThe data won't be changed!!!"
            )
            return data

        if (self.normalize and self.ringbufferNormalize == None):
            self.ringbufferNormalize = numpy.zeros(
                (self.lenNormalize, self.nChannels), dtype=numpy.double)

        # Convert the input data to double
        x = data.view(numpy.ndarray).astype(numpy.double)
        # Initialize the result data array
        filtered_data = numpy.zeros(x.shape)
        # Lists which are passed to the standadization
        # TODO: make self
        processing_filtered_data = None
        processing_ringbuffer = None
        processing_variables = None
        processing_index = None
        if (self.standardization):
            for channel_index in range(self.nChannels):
                # Copy the different data to the processing listst
                processing_filtered_data = numpy.array(
                    filtered_data[:, channel_index], 'd')
                processing_ringbuffer = numpy.array(
                    self.ringbuffer[:, channel_index], 'd')
                processing_variables = numpy.array(
                    self.variables[:, channel_index], 'd')
                processing_index = int(self.index[channel_index])
                if self.var_tools:
                    # Perform the standardization
                    # The module vt (variance_tools) is implemented in c using
                    # boost to wrap the code in Python
                    # The module is located in trunk/library/variance_tools
                    # and have to be compiled
                    self.index[channel_index] = vt.standardization(
                        processing_filtered_data,
                        numpy.array(x[:, channel_index],
                                    'd'), processing_ringbuffer,
                        processing_variables, self.width, processing_index)
                else:
                    self.index[channel_index] = self.standardisation(
                        processing_filtered_data,
                        numpy.array(x[:, channel_index],
                                    'd'), processing_ringbuffer,
                        processing_variables, self.width, processing_index)
                # Copy the processing lists back to the local variables
                filtered_data[:, channel_index] = processing_filtered_data
                self.ringbuffer[:, channel_index] = processing_ringbuffer
                self.variables[:, channel_index] = processing_variables
        else:
            for channel_index in range(self.nChannels):
                # Copy the different data to the processing listst
                processing_filtered_data = numpy.array(
                    filtered_data[:, channel_index], 'd')
                processing_ringbuffer = numpy.array(
                    self.ringbuffer[:, channel_index], 'd')
                processing_variables = numpy.array(
                    self.variables[:, channel_index], 'd')
                processing_index = int(self.index[channel_index])
                if self.var_tools:
                    # Perform the filtering with the variance
                    # The module vt (variance_tools) is implemented in c using
                    # boost to wrap the code in Python
                    # The module is located in trunk/library/variance_tools
                    # and have to be compiled
                    self.index[channel_index] = vt.filter(
                        processing_filtered_data,
                        numpy.array(x[:, channel_index],
                                    'd'), processing_ringbuffer,
                        processing_variables, self.width, processing_index)
                    if self.normalize:
                        lenData = len(processing_filtered_data)
                        self.ringbufferNormalize[0:-lenData,channel_index] = \
                            self.ringbufferNormalize[lenData:,channel_index]
                        self.ringbufferNormalize[-lenData:,channel_index] = \
                            processing_filtered_data[:]
                        processing_filtered_data /= numpy.max(
                            (50,
                             numpy.max(
                                 self.ringbufferNormalize[:, channel_index])))
                else:
                    self.index[channel_index] = self.variance(
                        processing_filtered_data,
                        numpy.array(x[:, channel_index],
                                    'd'), processing_ringbuffer,
                        processing_variables, self.width, processing_index)
                # Copy the processing lists back to the local variables
                filtered_data[:, channel_index] = processing_filtered_data
                self.ringbuffer[:, channel_index] = processing_ringbuffer
                self.variables[:, channel_index] = processing_variables
        # Return the result
        result_time_series = TimeSeries.replace_data(data, filtered_data)
        return result_time_series