Exemple #1
0
    def __init__(self):
        self.experiment_multiselect = widgets.SelectMultiple(
            options=list(DataReader.get_experiments_mapping().keys()),
            description='Experiments:',
            disabled=False,
            value=[],
        )

        self.learning_curve = LearningCurve()

        def experiment_multiselect_change_callback(change):
            if change.name == 'value' and change.new is not None:
                self.learning_curve.update(change.new)

        self.experiment_multiselect.observe(
            experiment_multiselect_change_callback, type='change')
        super(LearningCurvesTab, self).__init__(
            [self.experiment_multiselect, self.learning_curve])
Exemple #2
0
    def __init__(self, level, callback=None, widget=None):
        """
        Args:
            level: int, EXPERIMENT_LEVEL, MODEL_LEVEL, or EPISODE_LEVEL.
                   speicifes what this picker should pick.
            callback: if not none, when the user picks all the values
                      the callback will be called.
                      Note that for different levels the number of
                      parameters passed to callback is different.
            widget: if not none, when the user picks all the values
                    widget.update(*args) will be called.
                    Note that for different levels the number of
                    parameters passed to update is different.
        """
        children = []
        self.experiment_dropdown = widgets.Dropdown(
            options=list(DataReader.get_experiments_mapping().keys()),
            description='Experiment:',
            disabled=False,
            value=None,
        )
        self.callback = callback
        self.widget = widget

        children.append(self.experiment_dropdown)

        if level >= Picker.MODEL_LEVEL:

            self.seed_dropdown = widgets.Dropdown(
                description='Seed:',
                disabled=True,
            )
            children.append(self.seed_dropdown)

            self.checkpoint_dropdown = widgets.Dropdown(
                description='Checkpoint:',
                disabled=True,
            )
            children.append(self.checkpoint_dropdown)

        if level >= Picker.EPISODE_LEVEL:
            self.episode_dropdown = widgets.Dropdown(
                description='Episode:',
                disabled=True,
            )
            children.append(self.episode_dropdown)

        self.ignore_updates = False

        def experiment_dropdown_change_callback(change):
            if change.name == 'value' and change.new is not None:
                self.ignore_updates = True
                if level >= Picker.MODEL_LEVEL:
                    self.seed_dropdown.options = \
                        DataReader.find_option_values(
                            option='seed',
                            experiment=self.experiment_dropdown.value
                        )
                    self.seed_dropdown.value = None
                    self.seed_dropdown.disabled = False
                    self.checkpoint_dropdown.disabled = True
                    self.checkpoint_dropdown.value = None
                self.ignore_updates = False
                if level == Picker.EXPERIMENT_LEVEL:
                    self.call_callback(self.experiment_dropdown.value)

        def seed_dropdown_change_callback(change):
            if self.ignore_updates:
                return
            if change.name == 'value' and change.new is not None:
                self.ignore_updates = True
                self.checkpoint_dropdown.options = \
                    DataReader.find_option_values(
                        option='checkpoint',
                        experiment=self.experiment_dropdown.value,
                        seed=self.seed_dropdown.value
                    )
                self.checkpoint_dropdown.value = None
                self.checkpoint_dropdown.disabled = False
                self.ignore_updates = False

        def checkpoint_dropdown_change_callback(change):
            if self.ignore_updates:
                return

            if change.name == 'value' and change.new is not None:
                self.ignore_updates = True
                if level >= Picker.EPISODE_LEVEL:
                    self.episode_dropdown.options = \
                        DataReader.find_option_values(
                            option='episode',
                            experiment=self.experiment_dropdown.value,
                            seed=self.seed_dropdown.value,
                            checkpoint=self.checkpoint_dropdown.value
                        )
                    self.episode_dropdown.value = None
                    self.episode_dropdown.disabled = False
                self.ignore_updates = False

                if level == Picker.MODEL_LEVEL:
                    self.call_callback(self.experiment_dropdown.value,
                                       self.seed_dropdown.value,
                                       self.checkpoint_dropdown.value)

        def episode_dropdown_change_callback(change):
            if self.ignore_updates:
                return
            if change.name == 'value' and change.new is not None:
                if level == Picker.EPISODE_LEVEL:
                    self.call_callback(self.experiment_dropdown.value,
                                       self.seed_dropdown.value,
                                       self.checkpoint_dropdown.value,
                                       self.episode_dropdown.value)

                    self.experiment_dropdown.observe(
                        experiment_dropdown_change_callback, type='change')

        self.experiment_dropdown.observe(experiment_dropdown_change_callback,
                                         type='change')

        if level >= Picker.MODEL_LEVEL:
            self.seed_dropdown.observe(seed_dropdown_change_callback,
                                       type='change')
            self.checkpoint_dropdown.observe(
                checkpoint_dropdown_change_callback, type='change')

        if level >= Picker.EPISODE_LEVEL:
            self.episode_dropdown.observe(episode_dropdown_change_callback,
                                          type='change')

        super(Picker, self).__init__(children)