Пример #1
0
    def get_data(self, image_lst, loc_lst, visualize=False):
        """
        prepare data for training phase
        """
        data = []
        labels = []
        result = []

        for image, locs in zip(image_lst, loc_lst):

            demo_img = self.imread(image, 1)
            processed_img = self.preprocess(demo_img)
            segments = self.segment(processed_img)
            segments =[self.preprocess_segment(s) for s in segments]
            locations = list(loc_lst)
            # draw all counted objects in the image
            # visualize true cells
            # check if each segment is close to one true cell

            for seg in segments:
                data.append(seg.get_region(demo_img))
                result.append(seg)
            self.eval_segments(segments, locs)
            labels.extend([1 if s.detected else 0 for s in segments])

            if visualize:
                com.visualize_segments(demo_img, segments, locations)
                com.debug_im(processed_img)
                com.debug_im(demo_img, True)

        return data, labels, result
Пример #2
0
    def test(self, image, loc_lst, viz=False):
        """ test an image """
        demo = self.imread(image)
        assert demo is not None
        correct = 0
        locations = list(loc_lst)
        data, labels, segments = self.get_data([image], [loc_lst])
        total_segments = len(data)
        testing_data = [self._extraction.compute(im) for im in data]
        hist_data, hog_data = zip(*testing_data)
        print "total of segments: ", total_segments

        hist_data = np.array(hist_data, dtype=np.float32)
        hog_data = np.array(hog_data, dtype=np.float32)
        ############################
        # Normalize the histogram feature
        hist_data = normalize(hist_data, axis=1)

        ##############################
        # RandomizedPCA for the hog feature
        hog_data = self._pca.transform(hog_data)

        ##############################
        # Fusion of classifiers

        y_proba_lbp = self.clf_lbp.predict_proba(hog_data)
        y_proba_hist = self.clf_hist.predict_proba(hist_data)
        y_proba = None

        if self.op == "sum":
            y_proba = (y_proba_hist + y_proba_lbp)
        elif self.op == "max":
            y_proba = np.maximum(y_proba_hist, y_proba_lbp)
        elif self.op == "min":
            y_proba = np.minimum(y_proba_hist, y_proba_lbp)
        elif self.op == "mul":
            y_proba = np.multiply(y_proba_hist, y_proba_lbp)

        # print "y proba:", y_proba
        result = np.argmax(y_proba, axis=1)

        # score = accuracy_score(labels_test, predicted)
        # visualization
        for predicted, expected, s in zip(result, labels, segments):
            if predicted == expected:
                correct += 1
                s.detected = True

        if viz:
            com.visualize_segments(demo, segments, locations)
            com.debug_im(demo)
        return total_segments, correct
Пример #3
0
    def test(self, image, loc_lst, viz=False):
        """ test an image """
        demo = self.imread(image)
        correct = 0
        locations = list(loc_lst)

        data, labels, segments = self.get_data([image], [loc_lst])
        total_segments = len(data)
        testing_data = [self._extraction.compute(im)[0] for im in data]

        testing_data = np.vstack(testing_data)

        result = self._classifier.predict(testing_data)

        for predicted, expected, s in zip(result, labels, segments):
            if predicted == expected:
                correct += 1
                s.detected = True
        if viz:
            com.visualize_segments(demo, segments, locations)
            com.debug_im(demo)
        return correct, total_segments
Пример #4
0
    def test(self, image, loc_lst, viz=False):
        """ test an image """
        demo = self.imread(image)
        locations = loc_lst
        data, l, segments = self.get_data([image], [loc_lst])
        num_samples = len(data)
        labels = []
        features = []

        for idx, im in enumerate(data):
            f = self._extraction.compute(im, self._extraction.detect(im))[1]
            if f is not None:
                features.append(f)
                labels.append(l[idx])

        testing_data = []

        for feature in features:
            coeffs = sparse.encode(feature, self.dictionary, self.alpha)
            vector = pooling.max_pooling(coeffs)
            testing_data.append(vector)

        testing_data = np.vstack(testing_data)
        testing_data = np.float32(testing_data)

        labels = np.float32(labels)
        result = self._classifier.predict(testing_data)

        for predicted, expected, s in zip(result, labels, segments):
            if predicted == expected:
                s.detected = True
        correct = len(filter(lambda x: x.detected, segments))
        if viz:
            com.visualize_segments(demo, segments, locations)
            com.debug_im(demo)
        return correct, num_samples