Beispiel #1
0
def exp_manager(configuration, outdir):
    '''
        Main manager for running a set of experiments.
        
        :param configuration: YAML configuration file
        :param outdir: Main outdir file
    ''' 
    
    with open(configuration) as f:
        config = yaml.load(f)
    
    # Load sources configuration files
    dirname = os.path.dirname(configuration)
    
    pg_look_for_models(default_library, additional_paths=[dirname])

    
    sources, presentations = load_sources_config([dirname]) 

    for k in config:
        c = config[k]
        c['id'] = k
        source = c['source']
        if not source in sources:
            raise Exception('Unknown source %r in %r.' % (source, sources))
        c['source'] = sources[source]
        
        pres = c['presentation']
        if not pres in presentations:
            raise Exception('Unknown pres %r in %r.' % (pres, presentations))
        c['presentation'] = presentations[pres]

        c['outdir'] = os.path.join(outdir, c['id'])
        exp_run(c) 
    def init(self, init_data):
        data_central = init_data["data_central"]
        id_agent = init_data["id_agent"]
        id_robot = init_data["id_robot"]
        ds = data_central.get_dir_structure()
        basename = ds.get_video_basename(id_robot=id_robot, id_agent=id_agent, id_episode=None)
        if self.suffix:
            basename += "-%s" % self.suffix

        library = Library(default_library)
        pg_look_for_models(library)

        # load standard components
        import procgraph.components  # @UnusedImport

        # Give config passed by user
        config = dict(**self.code[1])

        can_provide = dict(**init_data)
        can_provide["basename"] = basename

        # Finding what configuration it wants
        block_type = self.code[0]
        # This is the config that it can accept
        can_accept = [x.variable for x in library.get_generator_for_block_type(block_type).config]
        # Now give extra
        for k, v in can_provide.items():
            if k in can_accept:
                config[k] = v

        self.model = library.instance(block_type, name="bridge", config=config)
        self.model.init()

        self.first_time = True
Beispiel #3
0
''' ProcGraph blocks to visualize flydra data. '''

import flydra_db_source
import flydra_db_image
import values2retina
import arena_display

# FIXME, make this importing code easier
import os
from procgraph.core.registrar import default_library
from procgraph.core.model_loader import pg_look_for_models
dir = os.path.join(os.path.dirname(__file__), 'models')

pg_look_for_models(default_library, additional_paths=[dir], ignore_env=True,
                   assign_to_module='procgraph_flydra')