コード例 #1
0
    def extract_parts(self, edges, edges_unspread, settings={}):
        #print 'strides', self.settings.get('strides', 1)
        if 'indices' in self.extra:
            feats = ag.features.code_parts_as_features_INDICES(edges, 
                                                       edges_unspread,
                                                       self._log_parts, self._log_invparts, 
                                                       self.extra['indices'],
                                                       self.threshold_in_counts(self.settings['threshold'], edges.shape[-1]), self.settings['patch_frame'], 
                                                       strides=self.settings.get('strides', 1), 
                                                       tau=self.settings.get('tau', 0.0),
                                                       max_threshold=self.threshold_in_counts(self.settings.get('max_threshold', 1.0), edges.shape[-1]))
        else:
            feats = ag.features.code_parts_as_features(edges, 
                                                       edges_unspread,
                                                       self._log_parts, self._log_invparts, 
                                                       self.threshold_in_counts(self.settings['threshold'], edges.shape[-1]), self.settings['patch_frame'], 
                                                       strides=self.settings.get('strides', 1), 
                                                       tau=self.settings.get('tau', 0.0),
                                                       max_threshold=self.threshold_in_counts(self.settings.get('max_threshold', 1.0), edges.shape[-1]))

        # Pad with background (TODO: maybe incorporate as an option to code_parts?)
        # This just makes things a lot easier, and we don't have to match for instance the
        # support which will be bigger if we don't do this.
        # TODO: If we're not using a support, this could be extremely detrimental!

        if settings.get('preserve_size'):
            # TODO: Create a function called pad_to_size that handles this better
            feats = ag.util.zeropad(feats, (self._log_parts.shape[1]//2, self._log_parts.shape[2]//2, 0))

            # TODO: This is a bit of a hack. This makes it handle even-sized parts
            if self._log_parts.shape[1] % 2 == 0:
                feats = feats[:-1]
            if self._log_parts.shape[2] % 2 == 0:
                feats = feats[:,:-1]

        sett = self.settings.copy()
        sett.update(settings)

        # Do spreading
        radii = sett.get('spread_radii', (0, 0))

        assert radii[0] == radii[1], 'Supports only axis symmetric radii spreading at this point'
        from amitgroup.features.features import array_bspread_new
        
        feats = array_bspread_new(feats, spread='box', radius=radii[0])

        cb = sett.get('crop_border')
        if cb:
            # Due to spreading, the area of influence can be greater
            # than what we're cutting off. That's why it's good to have
            # a cut_border property if you're training on real images.
            feats = feats[cb:-cb, cb:-cb]

        return feats 
コード例 #2
0
    def extract_parts(self, edges, edges_unspread, settings={}):
        #print 'strides', self.settings.get('strides', 1)
        if 'indices' in self.extra:
            feats = ag.features.code_parts_as_features_INDICES(
                edges,
                edges_unspread,
                self._log_parts,
                self._log_invparts,
                self.extra['indices'],
                self.threshold_in_counts(self.settings['threshold'],
                                         edges.shape[-1]),
                self.settings['patch_frame'],
                strides=self.settings.get('strides', 1),
                tau=self.settings.get('tau', 0.0),
                max_threshold=self.threshold_in_counts(
                    self.settings.get('max_threshold', 1.0), edges.shape[-1]))
        else:
            feats = ag.features.code_parts_as_features(
                edges,
                edges_unspread,
                self._log_parts,
                self._log_invparts,
                self.threshold_in_counts(self.settings['threshold'],
                                         edges.shape[-1]),
                self.settings['patch_frame'],
                strides=self.settings.get('strides', 1),
                tau=self.settings.get('tau', 0.0),
                max_threshold=self.threshold_in_counts(
                    self.settings.get('max_threshold', 1.0), edges.shape[-1]))

        # Pad with background (TODO: maybe incorporate as an option to code_parts?)
        # This just makes things a lot easier, and we don't have to match for instance the
        # support which will be bigger if we don't do this.
        # TODO: If we're not using a support, this could be extremely detrimental!

        if settings.get('preserve_size'):
            # TODO: Create a function called pad_to_size that handles this better
            feats = ag.util.zeropad(feats, (self._log_parts.shape[1] // 2,
                                            self._log_parts.shape[2] // 2, 0))

            # TODO: This is a bit of a hack. This makes it handle even-sized parts
            if self._log_parts.shape[1] % 2 == 0:
                feats = feats[:-1]
            if self._log_parts.shape[2] % 2 == 0:
                feats = feats[:, :-1]

        sett = self.settings.copy()
        sett.update(settings)

        # Do spreading
        radii = sett.get('spread_radii', (0, 0))

        assert radii[0] == radii[
            1], 'Supports only axis symmetric radii spreading at this point'
        from amitgroup.features.features import array_bspread_new

        feats = array_bspread_new(feats, spread='box', radius=radii[0])

        cb = sett.get('crop_border')
        if cb:
            # Due to spreading, the area of influence can be greater
            # than what we're cutting off. That's why it's good to have
            # a cut_border property if you're training on real images.
            feats = feats[cb:-cb, cb:-cb]

        return feats
コード例 #3
0
    def extract_parts(self, edges, edges_unspread, settings={}, dropout=None):
        bsett = self.bedges_settings()
        if 'indices' in self.extra:
            feats = ag.features.code_parts_as_features_INDICES(
                edges,
                edges_unspread,
                self._log_parts,
                self._log_invparts,
                self.extra['indices'],
                self.threshold_in_counts(self.settings['threshold'],
                                         edges.shape[-1],
                                         bsett['contrast_insensitive']),
                self.settings['patch_frame'],
                strides=self.settings.get('strides', 1),
                tau=self.settings.get('tau', 0.0),
                max_threshold=self.threshold_in_counts(
                    self.settings.get('max_threshold', 1.0), edges.shape[-1],
                    bsett['contrast_insensitive']))
        elif 0:
            feats = ag.features.code_parts_as_features(
                edges,
                edges_unspread,
                self._log_parts,
                self._log_invparts,
                self.threshold_in_counts(self.settings['threshold'],
                                         edges.shape[-1]),
                self.settings['patch_frame'],
                strides=self.settings.get('strides', 1),
                tau=self.settings.get('tau', 0.0),
                max_threshold=self.threshold_in_counts(
                    self.settings.get('max_threshold', 1.0), edges.shape[-1]))
        else:
            print("THIS IS THE ONE")
            partprobs = ag.features.code_parts(
                edges,
                edges_unspread,
                self._log_parts,
                self._log_invparts,
                self.threshold_in_counts(self.settings['threshold'],
                                         edges.shape[-1]),
                self.settings['patch_frame'],
                strides=self.settings.get('strides', 1),
                max_threshold=self.threshold_in_counts(
                    self.settings.get('max_threshold', 1.0), edges.shape[-1]))

            if dropout is not None:
                II = np.arange(self.num_features)
                np.random.shuffle(II)
                II = II[:int(dropout * self.num_features)]
                IJ = np.sort(np.concatenate([II * 2, (II * 2 + 1)]))
                yesno = np.concatenate([[0],
                                        np.bincount(IJ,
                                                    minlength=self.num_parts *
                                                    2)]).astype(bool)

                partprobs[:, :, yesno] = -np.inf

            # Sort out low-probability ones

            if 0:
                L = -np.ones(partprobs.shape[-1]) * np.inf
                L[0] = 0

                max2 = scipy.stats.scoreatpercentile(partprobs, 98, axis=-1)

                partprobs[max2 < -195] = L

                #feats = ag.features.convert_partprobs_to_feature_vector(partprobs.astype(np.float32), 2.0)
                feats = ag.features.convert_part_to_feature_vector(
                    partprobs.argmax(axis=-1).astype(np.uint32),
                    self.num_parts * 2)
            else:
                #feats = ag.features.convert_part_to_feature_vector(partprobs.argmax(axis=-1).astype(np.uint32), self.num_parts*2)
                #feats = convert_partprobs_to_feature_vector(partprobs.astype(np.float32), 0.0)
                feats = ag.features.convert_partprobs_to_feature_vector(
                    partprobs.astype(np.float32), self.settings.get('tau', 0))

        # Pad with background (TODO: maybe incorporate as an option to code_parts?)
        # This just makes things a lot easier, and we don't have to match for instance the
        # support which will be bigger if we don't do this.
        # TODO: If we're not using a support, this could be extremely detrimental!

        if settings.get('preserve_size'):
            # TODO: Create a function called pad_to_size that handles this better
            feats = ag.util.zeropad(feats, (self._log_parts.shape[1] // 2,
                                            self._log_parts.shape[2] // 2, 0))

            # TODO: This is a bit of a hack. This makes it handle even-sized parts
            if self._log_parts.shape[1] % 2 == 0:
                feats = feats[:-1]
            if self._log_parts.shape[2] % 2 == 0:
                feats = feats[:, :-1]

        sett = self.settings.copy()
        sett.update(settings)

        # Do spreading
        radii = sett.get('spread_radii', (0, 0))

        assert radii[0] == radii[
            1], 'Supports only axis symmetric radii spreading at this point'
        from amitgroup.features.features import array_bspread_new

        feats = array_bspread_new(feats, spread='box', radius=radii[0])

        cb = sett.get('crop_border')
        if cb:
            # Due to spreading, the area of influence can be greater
            # than what we're cutting off. That's why it's good to have
            # a cut_border property if you're training on real images.
            feats = feats[cb:-cb, cb:-cb]

        return feats
コード例 #4
0
    def extract_parts(self, edges, edges_unspread, settings={}, dropout=None):
        #print 'strides', self.settings.get('strides', 1)
        if 'indices' in self.extra:
            feats = ag.features.code_parts_as_features_INDICES(edges, 
                                                       edges_unspread,
                                                       self._log_parts, self._log_invparts, 
                                                       self.extra['indices'],
                                                       self.threshold_in_counts(self.settings['threshold'], edges.shape[-1]), self.settings['patch_frame'], 
                                                       strides=self.settings.get('strides', 1), 
                                                       tau=self.settings.get('tau', 0.0),
                                                       max_threshold=self.threshold_in_counts(self.settings.get('max_threshold', 1.0), edges.shape[-1]))
        elif 0:
            feats = ag.features.code_parts_as_features(edges, 
                                                       edges_unspread,
                                                       self._log_parts, self._log_invparts, 
                                                       self.threshold_in_counts(self.settings['threshold'], edges.shape[-1]), self.settings['patch_frame'], 
                                                       strides=self.settings.get('strides', 1), 
                                                       tau=self.settings.get('tau', 0.0),
                                                       max_threshold=self.threshold_in_counts(self.settings.get('max_threshold', 1.0), edges.shape[-1]))
        else:
            partprobs = ag.features.code_parts(edges,
                                               edges_unspread,
                                               self._log_parts, self._log_invparts, 
                                               self.threshold_in_counts(self.settings['threshold'], edges.shape[-1]), self.settings['patch_frame'], 
                                               strides=self.settings.get('strides', 1), 
                                               max_threshold=self.threshold_in_counts(self.settings.get('max_threshold', 1.0), edges.shape[-1]))

            if dropout is not None:
                II = np.arange(self.num_features)
                np.random.shuffle(II)
                II = II[:int(dropout*self.num_features)]
                IJ = np.sort(np.concatenate([II*2, (II*2+1)]))
                yesno = np.concatenate([[0], np.bincount(IJ, minlength=self.num_parts*2)]).astype(bool)

                partprobs[:,:,yesno] = -np.inf

            # Sort out low-probability ones

            if 0:
                L = -np.ones(partprobs.shape[-1]) * np.inf
                L[0] = 0
                
                max2 = scipy.stats.scoreatpercentile(partprobs, 98, axis=-1)

                partprobs[max2 < -195] = L

               #feats = ag.features.convert_partprobs_to_feature_vector(partprobs.astype(np.float32), 2.0)
                feats = ag.features.convert_part_to_feature_vector(partprobs.argmax(axis=-1).astype(np.uint32), self.num_parts*2)
            else:
                #feats = ag.features.convert_part_to_feature_vector(partprobs.argmax(axis=-1).astype(np.uint32), self.num_parts*2)
                #feats = convert_partprobs_to_feature_vector(partprobs.astype(np.float32), 0.0)
                feats = ag.features.convert_partprobs_to_feature_vector(partprobs.astype(np.float32), self.settings.get('tau', 0))


        # Pad with background (TODO: maybe incorporate as an option to code_parts?)
        # This just makes things a lot easier, and we don't have to match for instance the
        # support which will be bigger if we don't do this.
        # TODO: If we're not using a support, this could be extremely detrimental!

        if settings.get('preserve_size'):
            # TODO: Create a function called pad_to_size that handles this better
            feats = ag.util.zeropad(feats, (self._log_parts.shape[1]//2, self._log_parts.shape[2]//2, 0))

            # TODO: This is a bit of a hack. This makes it handle even-sized parts
            if self._log_parts.shape[1] % 2 == 0:
                feats = feats[:-1]
            if self._log_parts.shape[2] % 2 == 0:
                feats = feats[:,:-1]

        sett = self.settings.copy()
        sett.update(settings)

        # Do spreading
        radii = sett.get('spread_radii', (0, 0))

        assert radii[0] == radii[1], 'Supports only axis symmetric radii spreading at this point'
        from amitgroup.features.features import array_bspread_new
        
        feats = array_bspread_new(feats, spread='box', radius=radii[0])

        cb = sett.get('crop_border')
        if cb:
            # Due to spreading, the area of influence can be greater
            # than what we're cutting off. That's why it's good to have
            # a cut_border property if you're training on real images.
            feats = feats[cb:-cb, cb:-cb]

        return feats