예제 #1
0
    def __init__(self, stkfile, psz, scale=1.0):
        ImageStackBase.__init__(self)
        self.stkfile = stkfile
        raw_imgdata, hdr = mrc.readMRC(stkfile, inc_header=True)

        assert hdr['nx'] == hdr['ny']

        if psz is None:
            assert hdr['xlen'] == hdr['ylen']
            psz = hdr['xlen'] / hdr['nx']
            print(
                'No pixel size specified, using the one defined by the MRC header: {0}A'.format(psz))
            print('  WARNING: This may be inaccurate!')

        if scale != 1.0:
            Nsz = [np.round(scale * raw_imgdata.shape[0]),
                   np.round(scale * raw_imgdata.shape[1]),
                   raw_imgdata.shape[2]]
            imgdata = resize_ndarray(raw_imgdata, Nsz, axes=(0, 1))
            self.pixel_size = (psz * raw_imgdata.shape[0]) / imgdata.shape[1]
        else:
            imgdata = raw_imgdata
            self.pixel_size = psz

        self.imgdata = np.transpose(imgdata, axes=(2, 0, 1))

        self.num_images = self.imgdata.shape[0]
        self.num_pixels = self.imgdata.shape[1]
예제 #2
0
    def __init__(self, stkfile, psz, scale=1.0):
        ImageStackBase.__init__(self)
        self.stkfile = stkfile
        raw_imgdata, hdr = mrc.readMRC(stkfile, inc_header=True)

        assert hdr['nx'] == hdr['ny']

        if psz is None:
            assert hdr['xlen'] == hdr['ylen']
            psz = hdr['xlen'] / hdr['nx']
            print(
                'No pixel size specified, using the one defined by the MRC header: {0}A'.format(psz))
            print('  WARNING: This may be inaccurate!')

        if scale != 1.0:
            Nsz = [np.round(scale * raw_imgdata.shape[0]),
                   np.round(scale * raw_imgdata.shape[1]),
                   raw_imgdata.shape[2]]
            imgdata = resize_ndarray(raw_imgdata, Nsz, axes=(0, 1))
            self.pixel_size = (psz * raw_imgdata.shape[0]) / imgdata.shape[1]
        else:
            imgdata = raw_imgdata
            self.pixel_size = psz

        self.imgdata = np.transpose(imgdata, axes=(2, 0, 1))

        self.num_images = self.imgdata.shape[0]
        self.num_pixels = self.imgdata.shape[1]
    def __init__(self, stkfile, psz, scale=1.0):
        ImageStackBase.__init__(self)
        self.stkfile = stkfile
        raw_imgdata = sio.loadmat(stkfile)['particleData']
        hdr = {'zlen': 31559.1, 'xlen': 226.56, 'datatype': 2, 'nx': 64, 'ny': 64, 'nz': 8915, 'ylen': 226.56}

        assert hdr['nx'] == hdr['ny']

        if psz is None:
            assert hdr['xlen'] == hdr['ylen']
            psz = hdr['xlen'] / hdr['nx']
            print 'No pixel size specified, using the one defined by the MRC header: {0}A'.format(psz)
            print '   WARNING: This may be inaccurate!'

        if scale != 1.0:
            Nsz = [n.round(scale * raw_imgdata.shape[0]),
                   n.round(scale * raw_imgdata.shape[1]),
                   raw_imgdata.shape[2]]
            imgdata = resize_ndarray(raw_imgdata, Nsz, axes=(0, 1))
            self.pixel_size = (psz * raw_imgdata.shape[0]) / imgdata.shape[1]
        else:
            imgdata = raw_imgdata
            self.pixel_size = psz

        self.imgdata = n.transpose(imgdata, axes=(2, 0, 1))

        self.num_images = self.imgdata.shape[0]
        self.num_pixels = self.imgdata.shape[1]
예제 #4
0
    def __init__(self, stkfile, psz, scale=1.0):
        ImageStackBase.__init__(self)
        self.stkfile = stkfile
        raw_imgdata = sio.loadmat(stkfile)['particleData']
        hdr = {
            'zlen': 31559.1,
            'xlen': 226.56,
            'datatype': 2,
            'nx': 64,
            'ny': 64,
            'nz': 8915,
            'ylen': 226.56
        }

        assert hdr['nx'] == hdr['ny']

        if psz is None:
            assert hdr['xlen'] == hdr['ylen']
            psz = hdr['xlen'] / hdr['nx']
            print 'No pixel size specified, using the one defined by the MRC header: {0}A'.format(
                psz)
            print '   WARNING: This may be inaccurate!'

        if scale != 1.0:
            Nsz = [
                n.round(scale * raw_imgdata.shape[0]),
                n.round(scale * raw_imgdata.shape[1]), raw_imgdata.shape[2]
            ]
            imgdata = resize_ndarray(raw_imgdata, Nsz, axes=(0, 1))
            self.pixel_size = (psz * raw_imgdata.shape[0]) / imgdata.shape[1]
        else:
            imgdata = raw_imgdata
            self.pixel_size = psz

        self.imgdata = n.transpose(imgdata, axes=(2, 0, 1))

        self.num_images = self.imgdata.shape[0]
        self.num_pixels = self.imgdata.shape[1]
예제 #5
0
    def __init__(self, expbase, cmdparams=None):
        """cryodata is a CryoData instance. 
        expbase is a path to the base of folder where this experiment's files
        will be stored.  The folder above expbase will also be searched
        for .params files. These will be loaded first."""
        BackgroundWorker.__init__(self)

        # Create a background thread which handles IO
        self.io_queue = Queue()
        self.io_thread = Thread(target=self.ioworker)
        self.io_thread.daemon = True
        self.io_thread.start()

        # General setup ----------------------------------------------------
        self.expbase = expbase
        self.outbase = None

        # Paramter setup ---------------------------------------------------
        # search above expbase for params files
        _,_,filenames = os.walk(opj(expbase,'../')).next()
        self.paramfiles = [opj(opj(expbase,'../'), fname) \
                           for fname in filenames if fname.endswith('.params')]
        # search expbase for params files
        _,_,filenames = os.walk(opj(expbase)).next()
        self.paramfiles += [opj(expbase,fname)  \
                            for fname in filenames if fname.endswith('.params')]
        if 'local.params' in filenames:
            self.paramfiles += [opj(expbase,'local.params')]
        # load parameter files
        self.params = Params(self.paramfiles)
        self.cparams = None
        
        if cmdparams is not None:
            # Set parameter specified on the command line
            for k,v in cmdparams.iteritems():
                self.params[k] = v
                
        # Dataset setup -------------------------------------------------------
        self.imgpath = self.params['inpath']
        psize = self.params['resolution']
        if not isinstance(self.imgpath,list):
            imgstk = MRCImageStack(self.imgpath,psize)
        else:
            imgstk = CombinedImageStack([MRCImageStack(cimgpath,psize) for cimgpath in self.imgpath])

        if self.params.get('float_images',True):
            imgstk.float_images()
        
        self.ctfpath = self.params['ctfpath']
        mscope_params = self.params['microscope_params']
         
        if not isinstance(self.ctfpath,list):
            ctfstk = CTFStack(self.ctfpath,mscope_params)
        else:
            ctfstk = CombinedCTFStack([CTFStack(cctfpath,mscope_params) for cctfpath in self.ctfpath])


        self.cryodata = CryoDataset(imgstk,ctfstk)
        self.cryodata.compute_noise_statistics()
        if self.params.get('window_images',True):
            imgstk.window_images()
        minibatch_size = self.params['minisize']
        testset_size = self.params['test_imgs']
        partition = self.params.get('partition',0)
        num_partitions = self.params.get('num_partitions',1)
        seed = self.params['random_seed']
        if isinstance(partition,str):
            partition = eval(partition)
        if isinstance(num_partitions,str):
            num_partitions = eval(num_partitions)
        if isinstance(seed,str):
            seed = eval(seed)
        self.cryodata.divide_dataset(minibatch_size,testset_size,partition,num_partitions,seed)
        
        self.cryodata.set_datasign(self.params.get('datasign','auto'))
        if self.params.get('normalize_data',True):
            self.cryodata.normalize_dataset()

        self.voxel_size = self.cryodata.pixel_size


        # Iterations setup -------------------------------------------------
        self.iteration = 0 
        self.tic_epoch = None
        self.num_data_evals = 0
        self.eval_params()

        outdir = self.cparams.get('outdir',None)
        if outdir is None:
            if self.cparams.get('num_partitions',1) > 1:
                outdir = 'partition{0}'.format(self.cparams['partition'])
            else:
                outdir = ''
        self.outbase = opj(self.expbase,outdir)
        if not os.path.isdir(self.outbase):
            os.makedirs(self.outbase) 

        # Output setup -----------------------------------------------------
        self.ostream = OutputStream(opj(self.outbase,'stdout'))

        self.ostream(80*"=")
        self.ostream("Experiment: " + expbase + \
                     "    Kernel: " + self.params['kernel'])
        self.ostream("Started on " + socket.gethostname() + \
                     "    At: " + time.strftime('%B %d %Y: %I:%M:%S %p'))
        self.ostream("Git SHA1: " + gitutil.git_get_SHA1())
        self.ostream(80*"=")
        gitutil.git_info_dump(opj(self.outbase, 'gitinfo'))
        self.startdatetime = datetime.now()


        # for diagnostics and parameters
        self.diagout = Output(opj(self.outbase, 'diag'),runningout=False)
        # for stats (per image etc)
        self.statout = Output(opj(self.outbase, 'stat'),runningout=True)
        # for likelihoods of individual images
        self.likeout = Output(opj(self.outbase, 'like'),runningout=False)

        self.img_likes = n.empty(self.cryodata.N_D)
        self.img_likes[:] = n.inf

        # optimization state vars ------------------------------------------
        init_model = self.cparams.get('init_model',None)
        if init_model is not None:
            filename = init_model
            if filename.upper().endswith('.MRC'):
                M = readMRC(filename)
            else:
                with open(filename) as fp:
                    M = cPickle.load(fp)
                    if type(M)==list:
                        M = M[-1]['M'] 
            if M.shape != 3*(self.cryodata.N,):
                M = cryoem.resize_ndarray(M,3*(self.cryodata.N,),axes=(0,1,2))
        else:
            init_seed = self.cparams.get('init_random_seed',0)  + self.cparams.get('partition',0)
            print "Randomly generating initial density (init_random_seed = {0})...".format(init_seed), ; sys.stdout.flush()
            tic = time.time()
            M = cryoem.generate_phantom_density(self.cryodata.N, 0.95*self.cryodata.N/2.0, \
                                                5*self.cryodata.N/128.0, 30, seed=init_seed)
            print "done in {0}s".format(time.time() - tic)

        tic = time.time()
        print "Windowing and aligning initial density...", ; sys.stdout.flush()
        # window the initial density
        wfunc = self.cparams.get('init_window','circle')
        cryoem.window(M,wfunc)

        # Center and orient the initial density
        cryoem.align_density(M)
        print "done in {0:.2f}s".format(time.time() - tic)

        # apply the symmetry operator
        init_sym = get_symmetryop(self.cparams.get('init_symmetry',self.cparams.get('symmetry',None)))
        if init_sym is not None:
            tic = time.time()
            print "Applying symmetry operator...", ; sys.stdout.flush()
            M = init_sym.apply(M)
            print "done in {0:.2f}s".format(time.time() - tic)

        tic = time.time()
        print "Scaling initial model...", ; sys.stdout.flush()
        modelscale = self.cparams.get('modelscale','auto')
        mleDC, _, mleDC_est_std = self.cryodata.get_dc_estimate()
        if modelscale == 'auto':
            # Err on the side of a weaker prior by using a larger value for modelscale
            modelscale = (n.abs(mleDC) + 2*mleDC_est_std)/self.cryodata.N
            print "estimated modelscale = {0:.3g}...".format(modelscale), ; sys.stdout.flush()
            self.params['modelscale'] = modelscale
            self.cparams['modelscale'] = modelscale
        M *= modelscale/M.sum()
        print "done in {0:.2f}s".format(time.time() - tic)
        if mleDC_est_std/n.abs(mleDC) > 0.05:
            print "  WARNING: the DC component estimate has a high relative variance, it may be inaccurate!"
        if ((modelscale*self.cryodata.N - n.abs(mleDC)) / mleDC_est_std) > 3:
            print "  WARNING: the selected modelscale value is more than 3 std devs different than the estimated one.  Be sure this is correct."

        self.M = n.require(M,dtype=density.real_t)
        self.fM = density.real_to_fspace(M)
        self.dM = density.zeros_like(self.M)

        self.step = eval(self.cparams['optim_algo'])
        self.step.setup(self.cparams, self.diagout, self.statout, self.ostream)

        # Objective function setup --------------------------------------------
        param_type = self.cparams.get('parameterization','real')
        cplx_param = param_type in ['complex','complex_coeff','complex_herm_coeff']
        self.like_func = eval_objective(self.cparams['likelihood'])
        self.prior_func = eval_objective(self.cparams['prior'])

        if self.cparams.get('penalty',None) is not None:
            self.penalty_func = eval_objective(self.cparams['penalty'])
            prior_func = SumObjectives(self.prior_func.fspace, \
                                       [self.penalty_func,self.prior_func], None)
        else:
            prior_func = self.prior_func

        self.obj = SumObjectives(cplx_param,
                                 [self.like_func,prior_func], [None,None])
        self.obj.setup(self.cparams, self.diagout, self.statout, self.ostream)
        self.obj.set_dataset(self.cryodata)
        self.obj_wrapper = ObjectiveWrapper(param_type)

        self.last_save = time.time()
        
        self.logpost_history = FiniteRunningSum()
        self.like_history = FiniteRunningSum()

        # Importance Samplers -------------------------------------------------
        self.is_sym = get_symmetryop(self.cparams.get('is_symmetry',self.cparams.get('symmetry',None)))
        self.sampler_R = FixedFisherImportanceSampler('_R',self.is_sym)
        self.sampler_I = FixedFisherImportanceSampler('_I')
        self.sampler_S = FixedGaussianImportanceSampler('_S')
        self.like_func.set_samplers(sampler_R=self.sampler_R,sampler_I=self.sampler_I,sampler_S=self.sampler_S)