def _train(self, phi, data, y):
        X_n = phi(data)
        X = X_n[0]
        num_parts = X_n[1]
        num_orientations = X_n[2]
        num_true_parts = num_parts // num_orientations

        self._extra['training_comp'] = []

        K = int(y.max()) + 1

        mm_models = []

        for k in range(K):
            Xk = X[y == k]
            assert Xk.shape[-1] == 1

            from pnet.cyfuncs import index_map_pooling_multi

            # Rotate all the Xk samples

            print('A')
            XB = index_map_pooling_multi(Xk, num_parts, (1, 1), (1, 1))
            print('B')
            XB = XB.reshape(XB.shape[:-1] + (num_true_parts, num_orientations))

            blocks = []

            print('C')
            for ori in range(0, self._n_orientations):
                angle = ori / self._n_orientations * 360
                # Rotate all images, apply rotational spreading, then do
                # pooling

                from pnet.cyfuncs import rotate_index_map_pooling

                sr = self._pooling_settings.get('rotation_spreading_radius', 0)
                yy1 = rotate_index_map_pooling(Xk[..., 0], angle, sr,
                                               num_orientations,
                                               num_parts,
                                               self._pooling_settings['shape'])

                sh = yy1.shape[:3] + (num_orientations, num_true_parts)
                yy = yy1.reshape(sh)

                blocks.append(yy)

            blocks = np.asarray(blocks).transpose((1, 0, 2, 3, 4, 5))
            print('D')

            """
            from pnet.vzlog import default as vz

            import gv

            for i in range(self._n_orientations):
                gv.img.save_image(vz.impath(), blocks[0, i, :, :, 0].sum(-1))

            vz.finalize()
            """

            shape = blocks.shape[2:4] + (np.prod(blocks.shape[4:]),)

            # Flatten
            blocks = blocks.reshape(blocks.shape[:2] + (-1,))

            n_init = self._settings.get('n_init', 1)
            n_iter = self._settings.get('n_iter', 10)
            seed = self._settings.get('seed', 0)

            ORI = self._n_orientations
            POL = 1

            def cycles(X):
                return np.asarray([np.concatenate([X[i:], X[:i]])
                                   for i in range(len(X))])

            RR = np.arange(ORI)
            PP = np.arange(POL)
            II = [list(itr.product(PPi, RRi))
                  for PPi in cycles(PP)
                  for RRi in cycles(RR)]
            lookup = dict(zip(itr.product(PP, RR), itr.count()))
            permutations = [[lookup[ii] for ii in rows] for rows in II]
            permutations = np.asarray(permutations)

            print('E')

            if 1:
                mm = PermutationMM(n_components=self._n_components,
                                   permutations=permutations,
                                   n_iter=n_iter,
                                   n_init=n_init,
                                   random_state=seed,
                                   min_probability=self._min_prob)
                mm.fit(blocks)
                comps = mm.predict(blocks)
                mu_shape = (self._n_components * self._n_orientations,) + shape
                mu = mm.means_.reshape(mu_shape)

            else:
                num_angle = self._n_orientations
                d = np.prod(shape)
                sh = (num_angle, num_angle * d)
                permutation = np.empty(sh, dtype=np.int_)
                for a in range(num_angle):
                    if a == 0:
                        permutation[a] = np.arange(num_angle * d)
                    else:
                        permutation[a] = np.roll(permutation[a-1], -d)

                from pnet.bernoulli import em


                XX = blocks.reshape((blocks.shape[0], -1))
                print('F Digit:', d)
                ret = em(XX, self._n_components, n_iter,
                         permutation=permutation, numpy_rng=seed,
                         verbose=True)
                print('G')

                comps = ret[3]

                self._extra['training_comp'].append(ret[3])

                mu = ret[1].reshape((self._n_components * self._n_orientations,) + shape)

            if 0: # Build visualizations of all rotations

                ims10k = self._data
                label10k = y

                ims10k_d = ims10k[label10k == d]

                rot_ims10k = np.asarray([[rotate(im, -rot, resize=False) for rot in np.arange(n_orientations) * 360 / n_orientations] for im in ims10k_d])

                vispart_blocks = []

                for phase in range(n_orientations):
                    visparts = np.asarray([
                        rot_ims10k[comps[:, 0]==k, comps[comps[:, 0]==k][:, 1]].mean(0) for k in range(n_comp)
                    ])

                    M = 50

                    grid0 = pnet.plot.ImageGrid(n_comp, min(M, np.max(map(len, XX))), ims10k.shape[1:])
                    for k in range(n_comp):
                        for i in range(min(M, len(XX[k]))):
                            grid0.set_image(XX[k][i], k, i, vmin=0, vmax=1, cmap=cm.gray)
                    grid0.save(vz.impath(), scale=3)

                    for k in range(n_comp):
                        grid.set_image(visparts[k], d, k, vmin=0, vmax=1, cmap=cm.gray)




            mm_models.append(mu)
            print('H')


        self._models = np.asarray(mm_models)
예제 #2
0
    def train_from_samples(self, raw_patches, raw_originals):
        min_prob = self._settings.get('min_prob', 0.01)
        print(raw_patches.shape)
        print(raw_originals.shape)
        ORI = self._num_orientations
        POL = self._settings.get('polarities', 1)
        P = ORI * POL

        def cycles(X):
            return np.asarray([np.concatenate([X[i:], X[:i]]) for i in range(len(X))])

        RR = np.arange(ORI)
        PP = np.arange(POL)
        II = [list(itr.product(PPi, RRi)) for PPi in cycles(PP) for RRi in cycles(RR)]
        lookup = dict(zip(itr.product(PP, RR), itr.count()))
        n_init = self._settings.get('n_init', 1)
        n_iter = self._settings.get('n_iter', 10)
        seed = self._settings.get('em_seed', 0)


        num_angle = ORI
        d = np.prod(raw_patches.shape[2:])
        permutation = np.empty((num_angle, num_angle * d), dtype=np.int_)
        for a in range(num_angle):
            if a == 0:
                permutation[a] = np.arange(num_angle * d)
            else:
                permutation[a] = np.roll(permutation[a-1], d)
    
        from pnet.bernoulli import em      

        X = raw_patches.reshape((raw_patches.shape[0], -1))
        print(X.shape)
        if 1:
            ret = em(X, self._num_true_parts, n_iter,
                     mu_truncation=min_prob,
                     permutation=permutation, numpy_rng=seed,
                     verbose=True)

            comps = ret[3]
            self._parts = ret[1].reshape((self._num_true_parts * P,) + raw_patches.shape[2:])

            if comps.ndim == 1:
                comps = np.vstack([comps, np.zeros(len(comps), dtype=np.int_)]).T

        else:
            
            permutations = np.asarray([[lookup[ii] for ii in rows] for rows in II])

            from pnet.permutation_mm import PermutationMM
            mm = PermutationMM(n_components=self._num_true_parts, permutations=permutations, n_iter=n_iter, n_init=n_init, random_state=seed, min_probability=min_prob)

            Xflat = raw_patches.reshape(raw_patches.shape[:2] + (-1,))
            mm.fit(Xflat)


            comps = mm.predict(Xflat)

            self._parts = mm.means_.reshape((mm.n_components * P,) + raw_patches.shape[2:])

        if 0:
            # Reject some parts
            pp = self._parts[::self._num_orientations]
            Hall = -(pp * np.log2(pp) + (1 - pp) * np.log2(1 - pp))
            H = np.apply_over_axes(np.mean, Hall, [1, 2, 3]).ravel()

            from scipy.stats import scoreatpercentile

            Hth = scoreatpercentile(H, 50)
            ok = H <= Hth

            blocks = []
            for i in range(self._num_true_parts):
                if ok[i]:
                    blocks.append(self._parts[i*self._num_orientations:(i+1)*self._num_orientations])
            
            self._parts = np.concatenate(blocks)
            self._num_parts = len(self._parts)
            self._num_true_parts = self._num_parts // self._num_orientations 

        if 0:
            from pylab import cm
            grid2 = pnet.plot.ImageGrid(self._num_true_parts, 8, raw_originals.shape[2:])
            for n in range(self._num_true_parts):
                for e in range(8):
                    grid2.set_image(self._parts[n * self._num_orientations,...,e], n, e, vmin=0, vmax=1, cmap=cm.RdBu_r)
            grid2.save(vz.generate_filename(), scale=5)

        self._train_info['counts'] = np.bincount(comps[:,0], minlength=self._num_true_parts)

        print(self._train_info['counts'])

        self._visparts = np.asarray([
            raw_originals[comps[:,0]==k,comps[comps[:,0]==k][:,1]].mean(0) for k in range(self._num_true_parts)             
        ])

        if 0:

            XX = [
                raw_originals[comps[:,0]==k,comps[comps[:,0]==k][:,1]] for k in range(self._num_true_parts)             
            ]

            N = 100


            m = self._train_info['counts'].argmax()
            mcomps = comps[comps[:,0] == m]

            raw_originals_m = raw_originals[comps[:,0] == m]

            if 0:
                grid0 = pnet.plot.ImageGrid(N, self._num_orientations, raw_originals.shape[2:], border_color=(1, 1, 1))
                for i in range(min(N, raw_originals_m.shape[0])): 
                    for j in range(self._num_orientations):
                        grid0.set_image(raw_originals_m[i,(mcomps[i,1]+j)%self._num_orientations], i, j, vmin=0, vmax=1, cmap=cm.gray)

                grid0.save(vz.generate_filename(), scale=3)

                grid0 = pnet.plot.ImageGrid(self._num_true_parts, N, raw_originals.shape[2:], border_color=(1, 1, 1))
                for m in range(self._num_true_parts):
                    for i in range(min(N, XX[m].shape[0])):
                        grid0.set_image(XX[m][i], m, i, vmin=0, vmax=1, cmap=cm.gray)
                        #grid0.set_image(XX[i][j], i, j, vmin=0, vmax=1, cmap=cm.gray)

                grid0.save(vz.generate_filename(), scale=3)

                grid1 = pnet.plot.ImageGrid(1, self._num_true_parts, raw_originals.shape[2:], border_color=(1, 1, 1))
                for m in range(self._num_true_parts):
                    grid1.set_image(self._visparts[m], 0, m, vmin=0, vmax=1, cmap=cm.gray)

                grid1.save(vz.generate_filename(), scale=5)
예제 #3
0
    def train_from_samples(self, raw_patches, raw_originals):
        min_prob = self._settings['min_prob']

        ORI = self._num_orientations
        POL = self._settings.get('polarities', 1)
        P = ORI * POL

        def cycles(X):
            return np.asarray([np.concatenate([X[i:], X[:i]])
                               for i in range(len(X))])

        RR = np.arange(ORI)
        PP = np.arange(POL)
        II = [list(itr.product(PPi, RRi))
              for PPi in cycles(PP)
              for RRi in cycles(RR)]
        lookup = dict(zip(itr.product(PP, RR), itr.count()))
        n_init = self._settings.get('n_init', 1)
        n_iter = self._settings.get('n_iter', 10)
        seed = self._settings.get('em_seed', 0)

        num_angle = ORI
        d = np.prod(raw_patches.shape[2:])
        permutation = np.empty((num_angle, num_angle * d), dtype=np.int_)
        for a in range(num_angle):
            if a == 0:
                permutation[a] = np.arange(num_angle * d)
            else:
                permutation[a] = np.roll(permutation[a-1], d)

        permutations = [[lookup[ii] for ii in rows] for rows in II]
        permutations = np.asarray(permutations)

        from pnet.permutation_mm import PermutationMM
        mm = PermutationMM(n_components=self._num_true_parts,
                           permutations=permutations,
                           n_iter=n_iter,
                           n_init=n_init,
                           random_state=seed,
                           min_probability=min_prob)

        Xflat = raw_patches.reshape(raw_patches.shape[:2] + (-1,))
        mm.fit(Xflat)

        comps = mm.predict(Xflat)
        ml = self._num_true_parts
        counts = np.bincount(comps[:, 0], minlength=ml)

        ag.info('Training counts:', counts)

        # Reject some parts
        ok = counts >= self._settings['min_count']

        ag.info('Keeping', ok.sum(), 'out of', ok.size, 'parts')

        self._num_true_parts = ok.sum()
        mm.means_ = mm.means_[ok]
        mm.weights_ = mm.weights_[ok]
        counts_final = counts[ok]

        # Store info
        sh = (self._num_true_parts * P,) + raw_patches.shape[2:]
        self._parts = mm.means_.reshape(sh)
        self._parts_vis = self._parts.copy()

        if self._settings['circular']:
            sh = raw_patches.shape[2:4]
            assert sh[0] == sh[1], 'Must use square parts with circular'
            side = sh[0]

            off = -(side - 1) / 2

            # Remove edges and make circular
            x, y = np.meshgrid(np.arange(side) + off, np.arange(side) + off)

            mask = (x ** 2) + (y ** 2) <= (side / 2) ** 2

            mask0 = mask[np.newaxis, ..., np.newaxis]

            # We'll set them to any value (0.1). This could use better handling
            # if so that the likelihoods aren't ruined.
            self._parts = mask0 * self._parts + ~mask0 * 0.1
            self._parts_vis[:, ~mask, :] = np.nan

            from vzlog import default as vz
            from pylab import cm
            grid = ag.plot.ImageGrid(mask, cmap=cm.jet)
            grid.save(vz.impath(), scale=10)

        self._train_info['counts_initial'] = counts
        self._train_info['counts'] = counts_final

        # Visualize parts : we iterate only over 'ok' ones
        self._visparts = np.asarray([
            raw_originals[comps[:, 0] == k,
                          comps[comps[:, 0] == k][:, 1]].mean(0)
            for k in np.where(ok)[0]
        ])

        self._preprocess()
    def train(self, X_n, Y, OriginalX = None):
        X = X_n[0]
        num_parts = X_n[1]
        if(len(X_n) == 3):
            num_orientations = X_n[2]
        else:
            num_orientations = 1
        num_true_parts = num_parts // num_orientations

        self._extra['training_comp'] = []

        K = Y.max() + 1

        mm_models = []
        print(X.shape)
        for k in xrange(K):
            Xk = X[Y == k]

            assert Xk.shape[-1] == 1


            from pnet.cyfuncs import index_map_pooling_multi, orientation_pooling

            # Rotate all the Xk samples

            print('A')
            XB = index_map_pooling_multi(Xk, num_parts, (1, 1), (1, 1))
            print('B')
            XB = XB.reshape(XB.shape[:-1] + (num_true_parts, num_orientations))

            blocks = [] 

            print('C')
            for ori in xrange(0, self._n_orientations):
                angle = ori / self._n_orientations * 360
                # Rotate all images, apply rotational spreading, then do pooling

                if 0:
                    print(ori, 'R{')
                    rots = np.asarray([rotate_patch_map(XB[i], angle) for i in xrange(XB.shape[0])])
                    print(ori, 'R}')


                    print(ori, 'P{')
                    yy = orientation_pooling(rots, 
                                             self._pooling_settings['shape'],
                                             self._pooling_settings['strides'],
                                             self._pooling_settings.get('rotation_spreading_radius', 0))
                    print(ori, 'P}')

                from pnet.cyfuncs import rotate_index_map_pooling 


                if num_orientations !=1:
                    yy1 = rotate_index_map_pooling(Xk[...,0], angle, self._pooling_settings.get('rotation_spreading_radius', 0),
                                               num_orientations, 
                                               num_parts,
                                               self._pooling_settings['shape'])
                else:
                    from pnet.cyfuncs import index_map_pooling_multi as poolf
                    print(Xk.shape)
                    yy1 = poolf(Xk,num_parts,self._pooling_settings.get('shape'), self._pooling_settings.get('strides')) 
                print(yy1.shape, num_orientations, num_true_parts)
                yy = yy1.reshape(yy1.shape[:3] + (num_orientations, num_true_parts))
                blocks.append(yy)#.reshape(yy.shape[:-2] + (-1,)))

            blocks = np.asarray(blocks).transpose((1, 0, 2, 3, 4, 5))
            print('D')

            if 0:
                from pnet.vzlog import default as vz

                import gv

                for i in xrange(self._n_orientations):
                    gv.img.save_image(vz.generate_filename(), blocks[0,i,:,:,0].sum(-1))

                vz.finalize()

            shape = blocks.shape[2:4] + (np.prod(blocks.shape[4:]),)

            # Flatten
            blocks = blocks.reshape(blocks.shape[:2] + (-1,))

            n_init = self._settings.get('n_init', 1)
            n_iter = self._settings.get('n_iter', 10)
            seed = self._settings.get('em_seed', 0)

            ORI = self._n_orientations
            POL = 1

            P = ORI * POL


            def cycles(X):
                return np.asarray([np.concatenate([X[i:], X[:i]]) for i in xrange(len(X))])

            RR = np.arange(ORI)
            PP = np.arange(POL)
            II = [list(itr.product(PPi, RRi)) for PPi in cycles(PP) for RRi in cycles(RR)]
            lookup = dict(zip(itr.product(PP, RR), itr.count()))
            permutations = np.asarray([[lookup[ii] for ii in rows] for rows in II])

            print('E')

            if 0:
                mm = PermutationMM(n_components=self._n_components, 
                                   permutations=permutations,
                                   n_iter=n_iter, 
                                   n_init=n_init, 
                                   random_state=seed, 
                                   min_probability=self._min_prob)
                mm.fit(blocks)
                mu = mm.means_.reshape((self._n_components,)+shape)

            else:       
                num_angle = self._n_orientations
                d = np.prod(shape)
                permutation = np.empty((num_angle, num_angle * d), dtype=np.int_)
                for a in range(num_angle):
                    if a == 0:
                        permutation[a] = np.arange(num_angle * d)
                    else:
                        permutation[a] = np.roll(permutation[a-1], -d)

                from pnet.bernoulli import em      


                XX = blocks.reshape((blocks.shape[0], -1))
                print('F')
                ret = em(XX, self._n_components, n_iter,
                         permutation=permutation, numpy_rng=seed,
                         verbose=True)
                print('G')

                self._extra['training_comp'].append(ret[3])

                mu = ret[1].reshape((self._n_components * self._n_orientations,) + shape)


            
            mm_models.append(mu)
            print('H')


        self._models = np.asarray(mm_models)