How to handle memory error while modeling a dataset? about pyautolens HOT 2 CLOSED

from os import path
import sys
import json

workspace_path = path.join(path.sep, "your", "workspace", "path")

""" 
__AUTOLENS + DATA__
"""
import autofit as af
import autolens as al

dataset_name = [
    "lens_0", 
    "lens_1",  
    "lens_2",  
]

dataset_name = dataset_name[int(sys.argv[1])] # sys.argv[1] loads the first value passwed in from when Python is run

dataset_path = path.join(cosma_dataset_path, dataset_label, dataset_name)

imaging = al.Imaging.from_fits(
    image_path=f"{dataset_path}/image_lens_light_scaled.fits",
    psf_path=f"{dataset_path}/psf.fits",
    noise_map_path=f"{dataset_path}/noise_map_scaled.fits",
    pixel_scales=pixel_scales,
    name=dataset_name,
)

class pipeline:

    def __init__(self, system_identifier_name, lens_redshift, source_redshift, pixel_scales, core_usage=5, session=None, dataset_name=None):

        self.system_identifier_name = system_identifier_name
        self.lens_redshift = lens_redshift
        self.source_redshift = source_redshift
        self.pixel_scales = pixel_scales
        self.core_usage = core_usage
        self.session = session
        self.dataset_name = dataset_name

    def fit_system_autolens(self, residual_image, original_noise_map, original_psf, nlive, fit_mcmc=True, system_radius=8.0):

        image_object = al.Imaging(al.Array2D.manual(np.array(residual_image, dtype=float), pixel_scales=self.pixel_scales), # cutout
                                  al.Array2D.manual(np.array(original_noise_map, dtype=float), pixel_scales=self.pixel_scales), # noise_map 
                                  al.Kernel2D.manual(np.array(original_psf, dtype=float), pixel_scales=self.pixel_scales, shape_native=(100, 100))) # psf

        mask = al.Mask2D.circular(shape_native=image_object.shape_native, pixel_scales=image_object.pixel_scales, radius=system_radius)
        masked_object = image_object.apply_mask(mask=mask)

        # source galaxy model
        bulge = af.Model(al.lmp.EllSersic)
        source_galaxy_model = af.Model(al.Galaxy,
                                       redshift=self.source_redshift,
                                       bulge=bulge)
        # lens galaxy model
        lens_galaxy_model = af.Model(al.Galaxy,
                                     redshift=self.lens_redshift ,
                                     mass=al.mp.EllIsothermal)    

        autolens_model = af.Collection(galaxies=af.Collection(lens=lens_galaxy_model, source=source_galaxy_model))
        # autolens fit full bright distribution

        if fit_mcmc:
            search = af.Emcee(
                path_prefix='./',
                name=str(self.system_identifier_name)+'_source_light',
                unique_tag = self.dataset_name,
                session=self.session)
        else:
            print(str(self.system_identifier_name) + '_source_light', self.dataset_name)
            search = af.DynestyStatic(path_prefix = './',
                                      name = str(self.system_identifier_name) + '_source_light',
                                      unique_tag = self.dataset_name,
                                      nlive = nlive,
                                      number_of_cores = self.core_usage, # be carefull here! verify your core numbers
                                      session=self.session) 

        analysis = al.AnalysisImaging(dataset=masked_object)
        result = search.fit(model=autolens_model, analysis=analysis)
        return result