This method returns parameters as nested dicts in case of decision
        diagram parameter.
190696
def get_parameter_dd(self, parameter):
        
        dag = defaultdict(list)
        dag_elem = parameter.find('DAG')
        node = dag_elem.find('Node')
        root = node.get('var')

        def get_param(node):
            edges = defaultdict(list)
            for edge in node.findall('Edge'):
                if edge.find('Terminal') is not None:
                    edges[edge.get('val')] = edge.find('Terminal').text
                elif edge.find('Node') is not None:
                    node_cpd = defaultdict(list)
                    node_cpd[edge.find('Node').get('var')] = \
                        get_param(edge.find('Node'))
                    edges[edge.get('val')] = node_cpd
                elif edge.find('SubDAG') is not None:
                    subdag_attribute = defaultdict(list)
                    subdag_attribute['type'] = edge.find('SubDAG').get('type')
                    if subdag_attribute['type'] == 'template':
                        subdag_attribute['idref'] = \
                            edge.find('SubDAG').get('idref')
                    if edge.find('SubDAG').get('var'):
                        subdag_attribute['var'] = \
                            edge.find('SubDAG').get('var')
                    if edge.find('SubDAG').get('val'):
                        subdag_attribute['val'] = \
                            edge.find('SubDAG').get('val')
                    edges[edge.get('val')] = subdag_attribute
            return edges

        if parameter.find('SubDAGTemplate') is not None:
            SubDAGTemplate = parameter.find('SubDAGTemplate')
            subdag_root = SubDAGTemplate.find('Node')
            subdag_node = subdag_root.get('var')
            subdag_dict = defaultdict(list)
            subdag_dict[subdag_node] = get_param(subdag_root)
            dag['SubDAGTemplate'] = subdag_dict
            dag['id'] = SubDAGTemplate.get('id')
        dag[root] = get_param(node)
        return dag
844464
def map_parameters(cls, params):
        """"""

        d = {}
        for k, v in six.iteritems(params):
            d[cls.FIELD_MAP.get(k.lower(), k)] = v
        return d
376009
def get_params(self):
        
        assert self.binded and self.params_initialized

        arg_params = dict()
        aux_params = dict()

        for module in self._modules:
            arg, aux = module.get_params()
            arg_params.update(arg)
            aux_params.update(aux)

        return (arg_params, aux_params)
257751
def get_options_for_id(options: Dict[str, Dict[str, Any]], identifier: str):
    
    check_var(options, var_types=dict, var_name='options')
    res = options[identifier] if identifier in options.keys() else dict()
    check_var(res, var_types=dict, var_name='options[' + identifier + ']')
    return res
1357422
def parameters(self):
        
        parameters = []
        for k, v in self.__dict__.items():
            if k.startswith("_"):
                continue

            is_function = False
            is_set = False

            if callable(v):
                value = pickle.dumps(func_dump(v))
                is_function = True
            elif isinstance(v, set):
                value = list(v)
                is_set = True
            else:
                value = v

            parameters.append(dict(
                key=k,
                value=value,
                is_function=is_function,
                is_set=is_set
            ))

        return parameters
244080
def get_parameters(self):
        """"""
        d = {}
        for p in self.processors:
            parameter_names = list(p.PARAMETERS.keys())
            parameter_values = [getattr(p, n) for n in parameter_names]
            d.update(dict(zip(parameter_names, parameter_values)))
        return d
709432
def parameters(self):
        
        pyname = self.pyname
        if isinstance(pyname, pynames.ImportedName):
            pyname = pyname._get_imported_pyname()
        if isinstance(pyname, pynames.DefinedName):
            pyobject = pyname.get_object()
            if isinstance(pyobject, pyobjects.AbstractFunction):
                return pyobject.get_param_names()
1117145
def get(self):
        """"""
        options = {}
        for x in [self.axes, self.graphics, self.layout]:
            for k, v in list(x.get().items()):
                options[k] = v

        return options
118729
def _params(sig):
        """"""
        params = []
        for p in sig.parameters:
            param = sig.parameters[p]
            optional = param.default != inspect.Signature.empty
            default = UIBuilder._safe_default(param.default) if param.default != inspect.Signature.empty else ''
            annotation = param.annotation if param.annotation != inspect.Signature.empty else ''
            type = UIBuilder._guess_type(default)

            # Create the parameter attribute dict
            p_attr = {
                "name": param.name,
                "label": param.name,
                "optional": optional,
                "default": default,
                "description": annotation,
                "hide": False,
                "type": type,
                "kinds": None,
                "choices": [],
                "id": None,
                "events": None
            }

            # Special choices handling for boolean parameters
            if isinstance(default, bool):
                p_attr['choices'] = {
                    'True': 'true',
                    'False': 'false'
                }

            # Append it to the list
            params.append(p_attr)
        return params
368847
def get_parameters(self, graph=None):
        
        g = graph if graph is not None else self.tf_graph

        with g.as_default():
            with tf.Session() as self.tf_session:
                self.tf_saver.restore(self.tf_session, self.model_path)

                return {
                    'W': self.W.eval(),
                    'bh_': self.bh_.eval(),
                    'bv_': self.bv_.eval()
                }
1255421
def to_dict(self):
        
        return {
            'model_type': 'discretechoice',
            'model_expression': self.model_expression,
            'sample_size': self.sample_size,
            'name': self.name,
            'probability_mode': self.probability_mode,
            'choice_mode': self.choice_mode,
            'choosers_fit_filters': self.choosers_fit_filters,
            'choosers_predict_filters': self.choosers_predict_filters,
            'alts_fit_filters': self.alts_fit_filters,
            'alts_predict_filters': self.alts_predict_filters,
            'interaction_predict_filters': self.interaction_predict_filters,
            'estimation_sample_size': self.estimation_sample_size,
            'prediction_sample_size': self.prediction_sample_size,
            'choice_column': self.choice_column,
            'fitted': self.fitted,
            'log_likelihoods': self.log_likelihoods,
            'fit_parameters': (yamlio.frame_to_yaml_safe(self.fit_parameters)
                               if self.fitted else None)
        }
388428
def from_dict(cls, d):
        
        s = Structure.from_dict(d['structure'])
        return cls(s, d['graphs'])
72472
def get_params(self):
        
        params = super().get_params()
        params.update({'n_landmark': self.n_landmark,
                       'n_pca': self.n_pca})
        return params
1163977
def parameters(self):
        
        all_parameters = collections.OrderedDict()

        for component in self._components.values():

            for par in component.shape.parameters.values():

                all_parameters[par.path] = par

        return all_parameters
838357
def params(self):
        
        return [{"name": p_name, "type": p_type.__name__}
                for (p_name, p_type) in self.signature.parameter_types]
1117740
def _get_edge_dict(self):
        
        edge_dict = collections.defaultdict(lambda: [])
        if len(self._edges) > 0:
            for e in self._edges:
                data = e['data']
                key = tuple([data['i'], data['source'],
                            data['target'], data['polarity']])
                edge_dict[key] = data['id']
        return edge_dict
807771
def _get_edges(self):
        
        idset = set([id(x) for x in self.objects])
        self.edges = set([])
        for n in self.objects:
            refset = set([id(x) for x in get_referents(n)])
            for ref in refset.intersection(idset):
                label = ''
                members = None
                if isinstance(n, dict):
                    members = n.items()
                if not members:
                    members = named_refs(n)
                for (k, v) in members:
                    if id(v) == ref:
                        label = k
                        break
                self.edges.add(_Edge(id(n), ref, label))