示例#1
0
    def _apply(self, d):
        """ Applies classifier to a dataset. """

        # Perform preprocessing
        d = self.preprocessing.apply(d)
        slices = self.slice_node.apply(d)
        if slices == None:
            return

        if self.application_data == None or not self.application_data_valid:
            self.application_data = slices
            self.application_data_valid = True
        else:
            self.application_data += slices

        repetitions_recorded = numpy.min(
            self.application_data.ninstances_per_class)
        if repetitions_recorded == self.last_repetitions_recorded:
            return

        self.logger.debug('Repetitions recorded: %d' % repetitions_recorded)
        self.last_repetitions_recorded = repetitions_recorded
        if repetitions_recorded < self.num_repetitions:
            return

        d = psychic.erp(self.application_data)

        # Perform actual classification
        try:
            result = self.classification.apply(d).data

            candidates = numpy.flatnonzero(numpy.argmax(result, axis=0) == 0)
            if len(candidates) > 0:
                winner = candidates[numpy.argmax(result[0, candidates])]
            else:
                winner = numpy.argmax(result[0, :])

            if winner == self.last_winner:
                self.num_coherent_classifications += 1
            else:
                self.num_coherent_classifications = 0
                self.last_winner = winner

            self.logger.debug('Coherent classifications: %d' %
                              self.num_coherent_classifications)
            if self.num_coherent_classifications < self.classifications_needed:
                self.engine.provide_result([list(result[0, :]), 0])
                return

            self.logger.info('classification result: %d' % winner)
            self.engine.provide_result([list(result[0, :]), winner + 1])
            self.application_data_valid = False
            self.num_coherent_classifications = 0
            self.last_winner = -1
            self.last_repetitions_recorded = 0

        except ValueError as e:
            self.logger.error('Classification failed: %s' % e)
示例#2
0
    def train_(self, d):
        if self.time_range is None:
            self.time_range = (0, d.feat_lab[1][-1])
            self.time_idx = (0, d.data.shape[1]+1)
        else:
            sample_rate = psychic.get_samplerate(d)
            offset = d.feat_lab[1][0] * sample_rate
            self.time_idx = [int(x * sample_rate - offset) for x in self.time_range]
            self.time_idx[1] += 1

        erp = psychic.erp(d)

        if type(self.classes) == int:
            template = erp.data[:,:,self.classes]
        else:
            template = erp.data[:,:,self.classes[0]] - erp.data[:,:,self.classes[1]]
        self.template = DataSet(
            data = template,
            ids = [erp.feat_lab[1]],
            feat_lab=[erp.feat_lab[0]],
        )

        if self.peak_ch is None:
            peak = (self.time_idx[0] + np.argmax(np.abs(np.sum(
                self.template.data[:, self.time_idx[0]:self.time_idx[1]],
                axis=0))))
        else:
            if type(self.peak_ch) == str:
                self.peak_ch = self.template.feat_lab[0].index(self.peak_ch)
            peak = (self.time_idx[0] +
                np.argmax(np.abs(self.template.data[self.peak_ch,
                    self.time_idx[0]:self.time_idx[1]])))
        self.spatial_template = self.template.data[:, [peak]]

        sigma_x = psychic.nodes.spatialfilter.plain_cov0(self.template)
        sigma_x += self.reg * np.eye(sigma_x.shape[0])
        sigma_x_i = np.linalg.inv(sigma_x)
        W_spatial = sigma_x_i.dot(self.spatial_template)

        self.temp_template = psychic.nodes.spatialfilter.sfilter_plain(self.template, W_spatial)
        data = self.temp_template.data.copy()
        data[:,:self.time_idx[0]] = 0
        data[:,self.time_idx[1]:] = 0
        feat_lab=['temp']
        self.temp_template = DataSet(data=data, feat_lab=feat_lab, default=self.temp_template)
示例#3
0
    def train_(self, d):
        erp = psychic.erp(d)
        diff = erp.data[:,:,0] - erp.data[:,:,1]
        self.template = DataSet(
            data = diff,
            ids = [erp.feat_lab[1]],
            feat_lab=erp.feat_lab[0]
        )

        # p0 is the initial guess for the fitting coefficients (A, mu and sigma above)
        p0 = [.4, .05, 0., -0.25, .75, 1., 0]

        fit = fit_erp(diff, p0, d.feat_lab[0])
        data = fit.reshape(d.data.shape[0], -1)
        self.template = DataSet(data=data, default=self.template)

        peak = np.argmax(np.abs(np.sum(self.template.data, axis=0)))
        self.spatial_template = self.template.data[:, [peak]]

        sigma_x = psychic.nodes.spatialfilter.plain_cov0(self.template)
        sigma_x += self.reg * np.eye(sigma_x.shape[0])
        sigma_x_i = np.linalg.inv(sigma_x)
        W_spatial = sigma_x_i.dot(self.spatial_template)
        self.temp_template = psychic.nodes.spatialfilter.sfilter_plain(self.template, W_spatial)