# Autogenerated by nbdev

d = { 'settings': { 'branch': 'master',
                'doc_baseurl': '/jax-relax',
                'doc_host': 'https://birkhoffg.github.io',
                'git_url': 'https://github.com/birkhoffg/jax-relax',
                'lib_path': 'relax'},
  'syms': { 'relax.base': { 'relax.base.BaseConfig': ('base.html#baseconfig', 'relax/base.py'),
                            'relax.base.BaseConfig.load_from_json': ('base.html#baseconfig.load_from_json', 'relax/base.py'),
                            'relax.base.BaseConfig.save': ('base.html#baseconfig.save', 'relax/base.py'),
                            'relax.base.BaseModule': ('base.html#basemodule', 'relax/base.py'),
                            'relax.base.BaseModule.__init__': ('base.html#basemodule.__init__', 'relax/base.py'),
                            'relax.base.BaseModule.load_from_path': ('base.html#basemodule.load_from_path', 'relax/base.py'),
                            'relax.base.BaseModule.name': ('base.html#basemodule.name', 'relax/base.py'),
                            'relax.base.BaseModule.save': ('base.html#basemodule.save', 'relax/base.py'),
                            'relax.base.PredFnMixedin': ('base.html#predfnmixedin', 'relax/base.py'),
                            'relax.base.PredFnMixedin.pred_fn': ('base.html#predfnmixedin.pred_fn', 'relax/base.py'),
                            'relax.base.TrainableMixedin': ('base.html#trainablemixedin', 'relax/base.py'),
                            'relax.base.TrainableMixedin.is_trained': ('base.html#trainablemixedin.is_trained', 'relax/base.py'),
                            'relax.base.TrainableMixedin.train': ('base.html#trainablemixedin.train', 'relax/base.py')},
            'relax.data_module': { 'relax.data_module.BaseDataModule': ('data.html#basedatamodule', 'relax/data_module.py'),
                                   'relax.data_module.BaseDataModule._prepare': ( 'data.html#basedatamodule._prepare',
                                                                                  'relax/data_module.py'),
                                   'relax.data_module.BaseDataModule.apply_constraints': ( 'data.html#basedatamodule.apply_constraints',
                                                                                           'relax/data_module.py'),
                                   'relax.data_module.BaseDataModule.compute_reg_loss': ( 'data.html#basedatamodule.compute_reg_loss',
                                                                                          'relax/data_module.py'),
                                   'relax.data_module.DataModule': ('data.html#datamodule', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.__getitem__': ('data.html#datamodule.__getitem__', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.__init__': ('data.html#datamodule.__init__', 'relax/data_module.py'),
                                   'relax.data_module.DataModule._get_data': ('data.html#datamodule._get_data', 'relax/data_module.py'),
                                   'relax.data_module.DataModule._prepare': ('data.html#datamodule._prepare', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.apply_constraints': ( 'data.html#datamodule.apply_constraints',
                                                                                       'relax/data_module.py'),
                                   'relax.data_module.DataModule.compute_reg_loss': ( 'data.html#datamodule.compute_reg_loss',
                                                                                      'relax/data_module.py'),
                                   'relax.data_module.DataModule.from_config': ('data.html#datamodule.from_config', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.from_features': ( 'data.html#datamodule.from_features',
                                                                                   'relax/data_module.py'),
                                   'relax.data_module.DataModule.from_numpy': ('data.html#datamodule.from_numpy', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.from_path': ('data.html#datamodule.from_path', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.inverse_transform': ( 'data.html#datamodule.inverse_transform',
                                                                                       'relax/data_module.py'),
                                   'relax.data_module.DataModule.load_from_path': ( 'data.html#datamodule.load_from_path',
                                                                                    'relax/data_module.py'),
                                   'relax.data_module.DataModule.sample': ('data.html#datamodule.sample', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.save': ('data.html#datamodule.save', 'relax/data_module.py'),
                                   'relax.data_module.DataModule.set_transformations': ( 'data.html#datamodule.set_transformations',
                                                                                         'relax/data_module.py'),
                                   'relax.data_module.DataModule.transform': ('data.html#datamodule.transform', 'relax/data_module.py'),
                                   'relax.data_module.DataModuleConfig': ('data.html#datamoduleconfig', 'relax/data_module.py'),
                                   'relax.data_module.DataModuleConfig.shuffle': ( 'data.html#datamoduleconfig.shuffle',
                                                                                   'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin': ('data.html#datamoduleinfomixin', 'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.data': ( 'data.html#datamoduleinfomixin.data',
                                                                                   'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.dataset': ( 'data.html#datamoduleinfomixin.dataset',
                                                                                      'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.features': ( 'data.html#datamoduleinfomixin.features',
                                                                                       'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.label': ( 'data.html#datamoduleinfomixin.label',
                                                                                    'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.test_indices': ( 'data.html#datamoduleinfomixin.test_indices',
                                                                                           'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.train_indices': ( 'data.html#datamoduleinfomixin.train_indices',
                                                                                            'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.xs': ('data.html#datamoduleinfomixin.xs', 'relax/data_module.py'),
                                   'relax.data_module.DataModuleInfoMixin.ys': ('data.html#datamoduleinfomixin.ys', 'relax/data_module.py'),
                                   'relax.data_module._validate_dataname': ('data.html#_validate_dataname', 'relax/data_module.py'),
                                   'relax.data_module.dataframe2features': ('data.html#dataframe2features', 'relax/data_module.py'),
                                   'relax.data_module.dataframe2labels': ('data.html#dataframe2labels', 'relax/data_module.py'),
                                   'relax.data_module.dm_equals': ('data.html#dm_equals', 'relax/data_module.py'),
                                   'relax.data_module.download_data_module_files': ( 'data.html#download_data_module_files',
                                                                                     'relax/data_module.py'),
                                   'relax.data_module.features2config': ('data.html#features2config', 'relax/data_module.py'),
                                   'relax.data_module.features2pandas': ('data.html#features2pandas', 'relax/data_module.py'),
                                   'relax.data_module.load_data': ('data.html#load_data', 'relax/data_module.py'),
                                   'relax.data_module.to_feature': ('data.html#to_feature', 'relax/data_module.py')},
            'relax.data_utils.features': { 'relax.data_utils.features.Feature': ( 'data_utils/features.html#feature',
                                                                                  'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.__get_item__': ( 'data_utils/features.html#feature.__get_item__',
                                                                                               'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.__init__': ( 'data_utils/features.html#feature.__init__',
                                                                                           'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.__repr__': ( 'data_utils/features.html#feature.__repr__',
                                                                                           'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature._dispatch_transformation': ( 'data_utils/features.html#feature._dispatch_transformation',
                                                                                                           'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature._init_is_categorical': ( 'data_utils/features.html#feature._init_is_categorical',
                                                                                                       'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.apply_constraints': ( 'data_utils/features.html#feature.apply_constraints',
                                                                                                    'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.compute_reg_loss': ( 'data_utils/features.html#feature.compute_reg_loss',
                                                                                                   'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.data': ( 'data_utils/features.html#feature.data',
                                                                                       'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.fit': ( 'data_utils/features.html#feature.fit',
                                                                                      'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.fit_transform': ( 'data_utils/features.html#feature.fit_transform',
                                                                                                'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.from_dict': ( 'data_utils/features.html#feature.from_dict',
                                                                                            'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.inverse_transform': ( 'data_utils/features.html#feature.inverse_transform',
                                                                                                    'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.is_categorical': ( 'data_utils/features.html#feature.is_categorical',
                                                                                                 'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.is_immutable': ( 'data_utils/features.html#feature.is_immutable',
                                                                                               'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.set_transformation': ( 'data_utils/features.html#feature.set_transformation',
                                                                                                     'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.to_dict': ( 'data_utils/features.html#feature.to_dict',
                                                                                          'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.transform': ( 'data_utils/features.html#feature.transform',
                                                                                            'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.transformation': ( 'data_utils/features.html#feature.transformation',
                                                                                                 'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.transformed_data': ( 'data_utils/features.html#feature.transformed_data',
                                                                                                   'relax/data_utils/features.py'),
                                           'relax.data_utils.features.Feature.with_transformed_data': ( 'data_utils/features.html#feature.with_transformed_data',
                                                                                                        'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList': ( 'data_utils/features.html#featureslist',
                                                                                       'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.__getitem__': ( 'data_utils/features.html#featureslist.__getitem__',
                                                                                                   'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.__init__': ( 'data_utils/features.html#featureslist.__init__',
                                                                                                'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.__iter__': ( 'data_utils/features.html#featureslist.__iter__',
                                                                                                'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.__len__': ( 'data_utils/features.html#featureslist.__len__',
                                                                                               'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.__next__': ( 'data_utils/features.html#featureslist.__next__',
                                                                                                'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList._transform_data': ( 'data_utils/features.html#featureslist._transform_data',
                                                                                                       'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.apply_constraints': ( 'data_utils/features.html#featureslist.apply_constraints',
                                                                                                         'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.compute_reg_loss': ( 'data_utils/features.html#featureslist.compute_reg_loss',
                                                                                                        'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.feature_indices': ( 'data_utils/features.html#featureslist.feature_indices',
                                                                                                       'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.feature_name_indices': ( 'data_utils/features.html#featureslist.feature_name_indices',
                                                                                                            'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.features': ( 'data_utils/features.html#featureslist.features',
                                                                                                'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.features_and_indices': ( 'data_utils/features.html#featureslist.features_and_indices',
                                                                                                            'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.from_dict': ( 'data_utils/features.html#featureslist.from_dict',
                                                                                                 'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.inverse_transform': ( 'data_utils/features.html#featureslist.inverse_transform',
                                                                                                         'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.load_from_path': ( 'data_utils/features.html#featureslist.load_from_path',
                                                                                                      'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.save': ( 'data_utils/features.html#featureslist.save',
                                                                                            'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.set_transformations': ( 'data_utils/features.html#featureslist.set_transformations',
                                                                                                           'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.to_dict': ( 'data_utils/features.html#featureslist.to_dict',
                                                                                               'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.to_pandas': ( 'data_utils/features.html#featureslist.to_pandas',
                                                                                                 'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.transform': ( 'data_utils/features.html#featureslist.transform',
                                                                                                 'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.transformed_data': ( 'data_utils/features.html#featureslist.transformed_data',
                                                                                                        'relax/data_utils/features.py'),
                                           'relax.data_utils.features.FeaturesList.with_transformed_data': ( 'data_utils/features.html#featureslist.with_transformed_data',
                                                                                                             'relax/data_utils/features.py')},
            'relax.data_utils.preprocessing': { 'relax.data_utils.preprocessing.DataPreprocessor': ( 'data_utils/preprocessing.html#datapreprocessor',
                                                                                                     'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.__init__': ( 'data_utils/preprocessing.html#datapreprocessor.__init__',
                                                                                                              'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.fit': ( 'data_utils/preprocessing.html#datapreprocessor.fit',
                                                                                                         'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.fit_transform': ( 'data_utils/preprocessing.html#datapreprocessor.fit_transform',
                                                                                                                   'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.from_dict': ( 'data_utils/preprocessing.html#datapreprocessor.from_dict',
                                                                                                               'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.inverse_transform': ( 'data_utils/preprocessing.html#datapreprocessor.inverse_transform',
                                                                                                                       'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.to_dict': ( 'data_utils/preprocessing.html#datapreprocessor.to_dict',
                                                                                                             'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.DataPreprocessor.transform': ( 'data_utils/preprocessing.html#datapreprocessor.transform',
                                                                                                               'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.EncoderPreprocessor': ( 'data_utils/preprocessing.html#encoderpreprocessor',
                                                                                                        'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.EncoderPreprocessor._fit': ( 'data_utils/preprocessing.html#encoderpreprocessor._fit',
                                                                                                             'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.EncoderPreprocessor._inverse_transform': ( 'data_utils/preprocessing.html#encoderpreprocessor._inverse_transform',
                                                                                                                           'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.EncoderPreprocessor._transform': ( 'data_utils/preprocessing.html#encoderpreprocessor._transform',
                                                                                                                   'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.EncoderPreprocessor.from_dict': ( 'data_utils/preprocessing.html#encoderpreprocessor.from_dict',
                                                                                                                  'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.EncoderPreprocessor.to_dict': ( 'data_utils/preprocessing.html#encoderpreprocessor.to_dict',
                                                                                                                'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler': ( 'data_utils/preprocessing.html#minmaxscaler',
                                                                                                 'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler.__init__': ( 'data_utils/preprocessing.html#minmaxscaler.__init__',
                                                                                                          'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler.fit': ( 'data_utils/preprocessing.html#minmaxscaler.fit',
                                                                                                     'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler.from_dict': ( 'data_utils/preprocessing.html#minmaxscaler.from_dict',
                                                                                                           'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler.inverse_transform': ( 'data_utils/preprocessing.html#minmaxscaler.inverse_transform',
                                                                                                                   'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler.to_dict': ( 'data_utils/preprocessing.html#minmaxscaler.to_dict',
                                                                                                         'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.MinMaxScaler.transform': ( 'data_utils/preprocessing.html#minmaxscaler.transform',
                                                                                                           'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OneHotEncoder': ( 'data_utils/preprocessing.html#onehotencoder',
                                                                                                  'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OneHotEncoder.fit': ( 'data_utils/preprocessing.html#onehotencoder.fit',
                                                                                                      'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OneHotEncoder.inverse_transform': ( 'data_utils/preprocessing.html#onehotencoder.inverse_transform',
                                                                                                                    'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OneHotEncoder.transform': ( 'data_utils/preprocessing.html#onehotencoder.transform',
                                                                                                            'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OrdinalPreprocessor': ( 'data_utils/preprocessing.html#ordinalpreprocessor',
                                                                                                        'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OrdinalPreprocessor.fit': ( 'data_utils/preprocessing.html#ordinalpreprocessor.fit',
                                                                                                            'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OrdinalPreprocessor.inverse_transform': ( 'data_utils/preprocessing.html#ordinalpreprocessor.inverse_transform',
                                                                                                                          'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing.OrdinalPreprocessor.transform': ( 'data_utils/preprocessing.html#ordinalpreprocessor.transform',
                                                                                                                  'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing._check_xs': ( 'data_utils/preprocessing.html#_check_xs',
                                                                                              'relax/data_utils/preprocessing.py'),
                                                'relax.data_utils.preprocessing._unique': ( 'data_utils/preprocessing.html#_unique',
                                                                                            'relax/data_utils/preprocessing.py')},
            'relax.data_utils.transforms': { 'relax.data_utils.transforms.BaseTransformation': ( 'data_utils/transform.html#basetransformation',
                                                                                                 'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.__init__': ( 'data_utils/transform.html#basetransformation.__init__',
                                                                                                          'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.apply_constraints': ( 'data_utils/transform.html#basetransformation.apply_constraints',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.compute_reg_loss': ( 'data_utils/transform.html#basetransformation.compute_reg_loss',
                                                                                                                  'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.fit': ( 'data_utils/transform.html#basetransformation.fit',
                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.fit_transform': ( 'data_utils/transform.html#basetransformation.fit_transform',
                                                                                                               'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.from_dict': ( 'data_utils/transform.html#basetransformation.from_dict',
                                                                                                           'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.inverse_transform': ( 'data_utils/transform.html#basetransformation.inverse_transform',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.is_categorical': ( 'data_utils/transform.html#basetransformation.is_categorical',
                                                                                                                'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.to_dict': ( 'data_utils/transform.html#basetransformation.to_dict',
                                                                                                         'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.BaseTransformation.transform': ( 'data_utils/transform.html#basetransformation.transform',
                                                                                                           'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.GumbelSoftmaxTransformation': ( 'data_utils/transform.html#gumbelsoftmaxtransformation',
                                                                                                          'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.GumbelSoftmaxTransformation.__init__': ( 'data_utils/transform.html#gumbelsoftmaxtransformation.__init__',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.GumbelSoftmaxTransformation.apply_constraints': ( 'data_utils/transform.html#gumbelsoftmaxtransformation.apply_constraints',
                                                                                                                            'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.GumbelSoftmaxTransformation.soft_constraints': ( 'data_utils/transform.html#gumbelsoftmaxtransformation.soft_constraints',
                                                                                                                           'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.GumbelSoftmaxTransformation.to_dict': ( 'data_utils/transform.html#gumbelsoftmaxtransformation.to_dict',
                                                                                                                  'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation': ( 'data_utils/transform.html#identitytransformation',
                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.__init__': ( 'data_utils/transform.html#identitytransformation.__init__',
                                                                                                              'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.apply_constraints': ( 'data_utils/transform.html#identitytransformation.apply_constraints',
                                                                                                                       'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.fit': ( 'data_utils/transform.html#identitytransformation.fit',
                                                                                                         'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.fit_transform': ( 'data_utils/transform.html#identitytransformation.fit_transform',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.from_dict': ( 'data_utils/transform.html#identitytransformation.from_dict',
                                                                                                               'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.to_dict': ( 'data_utils/transform.html#identitytransformation.to_dict',
                                                                                                             'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.IdentityTransformation.transform': ( 'data_utils/transform.html#identitytransformation.transform',
                                                                                                               'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.MinMaxTransformation': ( 'data_utils/transform.html#minmaxtransformation',
                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.MinMaxTransformation.__init__': ( 'data_utils/transform.html#minmaxtransformation.__init__',
                                                                                                            'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.MinMaxTransformation.apply_constraints': ( 'data_utils/transform.html#minmaxtransformation.apply_constraints',
                                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.OneHotTransformation': ( 'data_utils/transform.html#onehottransformation',
                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.OrdinalTransformation': ( 'data_utils/transform.html#ordinaltransformation',
                                                                                                    'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.OrdinalTransformation.__init__': ( 'data_utils/transform.html#ordinaltransformation.__init__',
                                                                                                             'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.OrdinalTransformation.num_categories': ( 'data_utils/transform.html#ordinaltransformation.num_categories',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.SoftmaxTransformation': ( 'data_utils/transform.html#softmaxtransformation',
                                                                                                    'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.SoftmaxTransformation.__init__': ( 'data_utils/transform.html#softmaxtransformation.__init__',
                                                                                                             'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms.SoftmaxTransformation.soft_constraints': ( 'data_utils/transform.html#softmaxtransformation.soft_constraints',
                                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation': ( 'data_utils/transform.html#_defaulttransformation',
                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.apply_constraints': ( 'data_utils/transform.html#_defaulttransformation.apply_constraints',
                                                                                                                       'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.compute_reg_loss': ( 'data_utils/transform.html#_defaulttransformation.compute_reg_loss',
                                                                                                                      'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.fit': ( 'data_utils/transform.html#_defaulttransformation.fit',
                                                                                                         'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.fit_transform': ( 'data_utils/transform.html#_defaulttransformation.fit_transform',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.from_dict': ( 'data_utils/transform.html#_defaulttransformation.from_dict',
                                                                                                               'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.inverse_transform': ( 'data_utils/transform.html#_defaulttransformation.inverse_transform',
                                                                                                                       'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.is_categorical': ( 'data_utils/transform.html#_defaulttransformation.is_categorical',
                                                                                                                    'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.to_dict': ( 'data_utils/transform.html#_defaulttransformation.to_dict',
                                                                                                             'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._DefaultTransformation.transform': ( 'data_utils/transform.html#_defaulttransformation.transform',
                                                                                                               'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation': ( 'data_utils/transform.html#_onehottransformation',
                                                                                                    'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation.__init__': ( 'data_utils/transform.html#_onehottransformation.__init__',
                                                                                                             'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation.apply_constraints': ( 'data_utils/transform.html#_onehottransformation.apply_constraints',
                                                                                                                      'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation.compute_reg_loss': ( 'data_utils/transform.html#_onehottransformation.compute_reg_loss',
                                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation.hard_constraints': ( 'data_utils/transform.html#_onehottransformation.hard_constraints',
                                                                                                                     'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation.num_categories': ( 'data_utils/transform.html#_onehottransformation.num_categories',
                                                                                                                   'relax/data_utils/transforms.py'),
                                             'relax.data_utils.transforms._OneHotTransformation.soft_constraints': ( 'data_utils/transform.html#_onehottransformation.soft_constraints',
                                                                                                                     'relax/data_utils/transforms.py')},
            'relax.docs': { 'relax.docs.CustomizedMarkdownRenderer': ('docs.html#customizedmarkdownrenderer', 'relax/docs.py'),
                            'relax.docs.CustomizedMarkdownRenderer.__init__': ( 'docs.html#customizedmarkdownrenderer.__init__',
                                                                                'relax/docs.py'),
                            'relax.docs.CustomizedMarkdownRenderer._check_sym': ( 'docs.html#customizedmarkdownrenderer._check_sym',
                                                                                  'relax/docs.py'),
                            'relax.docs.CustomizedMarkdownRenderer._repr_markdown_': ( 'docs.html#customizedmarkdownrenderer._repr_markdown_',
                                                                                       'relax/docs.py'),
                            'relax.docs.CustomizedMarkdownRenderer.hook_methods': ( 'docs.html#customizedmarkdownrenderer.hook_methods',
                                                                                    'relax/docs.py'),
                            'relax.docs.ListDocment': ('docs.html#listdocment', 'relax/docs.py'),
                            'relax.docs.ListDocment.__init__': ('docs.html#listdocment.__init__', 'relax/docs.py'),
                            'relax.docs.ListDocment._repre_mardown': ('docs.html#listdocment._repre_mardown', 'relax/docs.py'),
                            'relax.docs.ParserMarkdownRenderer': ('docs.html#parsermarkdownrenderer', 'relax/docs.py'),
                            'relax.docs.ParserMarkdownRenderer.__init__': ('docs.html#parsermarkdownrenderer.__init__', 'relax/docs.py'),
                            'relax.docs._bold': ('docs.html#_bold', 'relax/docs.py'),
                            'relax.docs._docment_parser': ('docs.html#_docment_parser', 'relax/docs.py'),
                            'relax.docs._fmt_sig': ('docs.html#_fmt_sig', 'relax/docs.py'),
                            'relax.docs._inner_list2mdlist': ('docs.html#_inner_list2mdlist', 'relax/docs.py'),
                            'relax.docs._italic': ('docs.html#_italic', 'relax/docs.py'),
                            'relax.docs._params_mdlist': ('docs.html#_params_mdlist', 'relax/docs.py'),
                            'relax.docs._repr_markdown': ('docs.html#_repr_markdown', 'relax/docs.py'),
                            'relax.docs._return_mdlist': ('docs.html#_return_mdlist', 'relax/docs.py'),
                            'relax.docs._show_param': ('docs.html#_show_param', 'relax/docs.py'),
                            'relax.docs._show_params_return': ('docs.html#_show_params_return', 'relax/docs.py')},
            'relax.evaluate': { 'relax.evaluate.BaseEvalMetrics': ('evaluate.html#baseevalmetrics', 'relax/evaluate.py'),
                                'relax.evaluate.BaseEvalMetrics.__call__': ('evaluate.html#baseevalmetrics.__call__', 'relax/evaluate.py'),
                                'relax.evaluate.BaseEvalMetrics.__init__': ('evaluate.html#baseevalmetrics.__init__', 'relax/evaluate.py'),
                                'relax.evaluate.BaseEvalMetrics.__str__': ('evaluate.html#baseevalmetrics.__str__', 'relax/evaluate.py'),
                                'relax.evaluate.ManifoldDist': ('evaluate.html#manifolddist', 'relax/evaluate.py'),
                                'relax.evaluate.ManifoldDist.__call__': ('evaluate.html#manifolddist.__call__', 'relax/evaluate.py'),
                                'relax.evaluate.ManifoldDist.__init__': ('evaluate.html#manifolddist.__init__', 'relax/evaluate.py'),
                                'relax.evaluate.PredictiveAccuracy': ('evaluate.html#predictiveaccuracy', 'relax/evaluate.py'),
                                'relax.evaluate.PredictiveAccuracy.__call__': ( 'evaluate.html#predictiveaccuracy.__call__',
                                                                                'relax/evaluate.py'),
                                'relax.evaluate.PredictiveAccuracy.__init__': ( 'evaluate.html#predictiveaccuracy.__init__',
                                                                                'relax/evaluate.py'),
                                'relax.evaluate.Proximity': ('evaluate.html#proximity', 'relax/evaluate.py'),
                                'relax.evaluate.Proximity.__call__': ('evaluate.html#proximity.__call__', 'relax/evaluate.py'),
                                'relax.evaluate.Proximity.__init__': ('evaluate.html#proximity.__init__', 'relax/evaluate.py'),
                                'relax.evaluate.Runtime': ('evaluate.html#runtime', 'relax/evaluate.py'),
                                'relax.evaluate.Runtime.__call__': ('evaluate.html#runtime.__call__', 'relax/evaluate.py'),
                                'relax.evaluate.Runtime.__init__': ('evaluate.html#runtime.__init__', 'relax/evaluate.py'),
                                'relax.evaluate.Sparsity': ('evaluate.html#sparsity', 'relax/evaluate.py'),
                                'relax.evaluate.Sparsity.__call__': ('evaluate.html#sparsity.__call__', 'relax/evaluate.py'),
                                'relax.evaluate.Sparsity.__init__': ('evaluate.html#sparsity.__init__', 'relax/evaluate.py'),
                                'relax.evaluate.Validity': ('evaluate.html#validity', 'relax/evaluate.py'),
                                'relax.evaluate.Validity.__call__': ('evaluate.html#validity.__call__', 'relax/evaluate.py'),
                                'relax.evaluate.Validity.__init__': ('evaluate.html#validity.__init__', 'relax/evaluate.py'),
                                'relax.evaluate._get_metric': ('evaluate.html#_get_metric', 'relax/evaluate.py'),
                                'relax.evaluate.benchmark_cfs': ('evaluate.html#benchmark_cfs', 'relax/evaluate.py'),
                                'relax.evaluate.compute_proximity': ('evaluate.html#compute_proximity', 'relax/evaluate.py'),
                                'relax.evaluate.compute_single_proximity': ('evaluate.html#compute_single_proximity', 'relax/evaluate.py'),
                                'relax.evaluate.compute_single_sparsity': ('evaluate.html#compute_single_sparsity', 'relax/evaluate.py'),
                                'relax.evaluate.compute_single_validity': ('evaluate.html#compute_single_validity', 'relax/evaluate.py'),
                                'relax.evaluate.compute_sparsity': ('evaluate.html#compute_sparsity', 'relax/evaluate.py'),
                                'relax.evaluate.compute_validity': ('evaluate.html#compute_validity', 'relax/evaluate.py'),
                                'relax.evaluate.evaluate_cfs': ('evaluate.html#evaluate_cfs', 'relax/evaluate.py'),
                                'relax.evaluate.l2_ann': ('evaluate.html#l2_ann', 'relax/evaluate.py'),
                                'relax.evaluate.pairwise_distances': ('evaluate.html#pairwise_distances', 'relax/evaluate.py')},
            'relax.explain': { 'relax.explain.Explanation': ('explain.html#explanation', 'relax/explain.py'),
                               'relax.explain.Explanation.__getitem__': ('explain.html#explanation.__getitem__', 'relax/explain.py'),
                               'relax.explain.Explanation.__init__': ('explain.html#explanation.__init__', 'relax/explain.py'),
                               'relax.explain.Explanation.__repr__': ('explain.html#explanation.__repr__', 'relax/explain.py'),
                               'relax.explain.Explanation.cfs': ('explain.html#explanation.cfs', 'relax/explain.py'),
                               'relax.explain.Explanation.copy': ('explain.html#explanation.copy', 'relax/explain.py'),
                               'relax.explain.Explanation.data_name': ('explain.html#explanation.data_name', 'relax/explain.py'),
                               'relax.explain.Explanation.feature_indices': ( 'explain.html#explanation.feature_indices',
                                                                              'relax/explain.py'),
                               'relax.explain.Explanation.features_and_indices': ( 'explain.html#explanation.features_and_indices',
                                                                                   'relax/explain.py'),
                               'relax.explain.Explanation.load_from_path': ('explain.html#explanation.load_from_path', 'relax/explain.py'),
                               'relax.explain.Explanation.save': ('explain.html#explanation.save', 'relax/explain.py'),
                               'relax.explain.fake_explanation': ('explain.html#fake_explanation', 'relax/explain.py'),
                               'relax.explain.generate_cf_explanations': ('explain.html#generate_cf_explanations', 'relax/explain.py'),
                               'relax.explain.prepare_cf_module': ('explain.html#prepare_cf_module', 'relax/explain.py'),
                               'relax.explain.prepare_pred_fn': ('explain.html#prepare_pred_fn', 'relax/explain.py'),
                               'relax.explain.prepare_rng_keys': ('explain.html#prepare_rng_keys', 'relax/explain.py')},
            'relax.import_essentials': {},
            'relax.legacy.ckpt_manager': { 'relax.legacy.ckpt_manager.CheckpointManager': ( 'legacy/ckpt_manager.html#checkpointmanager',
                                                                                            'relax/legacy/ckpt_manager.py'),
                                           'relax.legacy.ckpt_manager.CheckpointManager.__init__': ( 'legacy/ckpt_manager.html#checkpointmanager.__init__',
                                                                                                     'relax/legacy/ckpt_manager.py'),
                                           'relax.legacy.ckpt_manager.CheckpointManager.delete_net_opt': ( 'legacy/ckpt_manager.html#checkpointmanager.delete_net_opt',
                                                                                                           'relax/legacy/ckpt_manager.py'),
                                           'relax.legacy.ckpt_manager.CheckpointManager.save_net_opt': ( 'legacy/ckpt_manager.html#checkpointmanager.save_net_opt',
                                                                                                         'relax/legacy/ckpt_manager.py'),
                                           'relax.legacy.ckpt_manager.CheckpointManager.update_checkpoints': ( 'legacy/ckpt_manager.html#checkpointmanager.update_checkpoints',
                                                                                                               'relax/legacy/ckpt_manager.py'),
                                           'relax.legacy.ckpt_manager.load_checkpoint': ( 'legacy/ckpt_manager.html#load_checkpoint',
                                                                                          'relax/legacy/ckpt_manager.py'),
                                           'relax.legacy.ckpt_manager.save_checkpoint': ( 'legacy/ckpt_manager.html#save_checkpoint',
                                                                                          'relax/legacy/ckpt_manager.py')},
            'relax.legacy.import_essentials': {},
            'relax.legacy.logger': { 'relax.legacy.logger.Logger': ('legacy/logger.html#logger', 'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.__init__': ( 'legacy/logger.html#logger.__init__',
                                                                              'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.close': ('legacy/logger.html#logger.close', 'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.get_last_logs': ( 'legacy/logger.html#logger.get_last_logs',
                                                                                   'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.log': ('legacy/logger.html#logger.log', 'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.log_dict': ( 'legacy/logger.html#logger.log_dict',
                                                                              'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.log_dir': ('legacy/logger.html#logger.log_dir', 'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.on_epoch_finished': ( 'legacy/logger.html#logger.on_epoch_finished',
                                                                                       'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.on_epoch_started': ( 'legacy/logger.html#logger.on_epoch_started',
                                                                                      'relax/legacy/logger.py'),
                                     'relax.legacy.logger.Logger.save_hyperparams': ( 'legacy/logger.html#logger.save_hyperparams',
                                                                                      'relax/legacy/logger.py')},
            'relax.legacy.module': { 'relax.legacy.module.BaseNetwork': ('legacy/module.html#basenetwork', 'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseNetwork.__call__': ( 'legacy/module.html#basenetwork.__call__',
                                                                                   'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule': ( 'legacy/module.html#basetrainingmodule',
                                                                                 'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.init_logger': ( 'legacy/module.html#basetrainingmodule.init_logger',
                                                                                             'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.init_net_opt': ( 'legacy/module.html#basetrainingmodule.init_net_opt',
                                                                                              'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.log': ( 'legacy/module.html#basetrainingmodule.log',
                                                                                     'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.log_dict': ( 'legacy/module.html#basetrainingmodule.log_dict',
                                                                                          'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.save_hyperparameters': ( 'legacy/module.html#basetrainingmodule.save_hyperparameters',
                                                                                                      'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.training_step': ( 'legacy/module.html#basetrainingmodule.training_step',
                                                                                               'relax/legacy/module.py'),
                                     'relax.legacy.module.BaseTrainingModule.validation_step': ( 'legacy/module.html#basetrainingmodule.validation_step',
                                                                                                 'relax/legacy/module.py'),
                                     'relax.legacy.module.DenseBlock': ('legacy/module.html#denseblock', 'relax/legacy/module.py'),
                                     'relax.legacy.module.DenseBlock.__call__': ( 'legacy/module.html#denseblock.__call__',
                                                                                  'relax/legacy/module.py'),
                                     'relax.legacy.module.DenseBlock.__init__': ( 'legacy/module.html#denseblock.__init__',
                                                                                  'relax/legacy/module.py'),
                                     'relax.legacy.module.MLP': ('legacy/module.html#mlp', 'relax/legacy/module.py'),
                                     'relax.legacy.module.MLP.__call__': ('legacy/module.html#mlp.__call__', 'relax/legacy/module.py'),
                                     'relax.legacy.module.MLP.__init__': ('legacy/module.html#mlp.__init__', 'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveModel': ( 'legacy/module.html#predictivemodel',
                                                                              'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveModel.__call__': ( 'legacy/module.html#predictivemodel.__call__',
                                                                                       'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveModel.__init__': ( 'legacy/module.html#predictivemodel.__init__',
                                                                                       'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveModelConfigs': ( 'legacy/module.html#predictivemodelconfigs',
                                                                                     'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule': ( 'legacy/module.html#predictivetrainingmodule',
                                                                                       'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.__init__': ( 'legacy/module.html#predictivetrainingmodule.__init__',
                                                                                                'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule._training_step': ( 'legacy/module.html#predictivetrainingmodule._training_step',
                                                                                                      'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.forward': ( 'legacy/module.html#predictivetrainingmodule.forward',
                                                                                               'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.init_net_opt': ( 'legacy/module.html#predictivetrainingmodule.init_net_opt',
                                                                                                    'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.loss_fn': ( 'legacy/module.html#predictivetrainingmodule.loss_fn',
                                                                                               'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.pred_fn': ( 'legacy/module.html#predictivetrainingmodule.pred_fn',
                                                                                               'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.training_step': ( 'legacy/module.html#predictivetrainingmodule.training_step',
                                                                                                     'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModule.validation_step': ( 'legacy/module.html#predictivetrainingmodule.validation_step',
                                                                                                       'relax/legacy/module.py'),
                                     'relax.legacy.module.PredictiveTrainingModuleConfigs': ( 'legacy/module.html#predictivetrainingmoduleconfigs',
                                                                                              'relax/legacy/module.py')},
            'relax.legacy.trainer': { 'relax.legacy.trainer.TrainingConfigs': ( 'legacy/trainer.html#trainingconfigs',
                                                                                'relax/legacy/trainer.py'),
                                      'relax.legacy.trainer.TrainingConfigs.PRNGSequence': ( 'legacy/trainer.html#trainingconfigs.prngsequence',
                                                                                             'relax/legacy/trainer.py'),
                                      'relax.legacy.trainer.train_model': ('legacy/trainer.html#train_model', 'relax/legacy/trainer.py'),
                                      'relax.legacy.trainer.train_model_with_states': ( 'legacy/trainer.html#train_model_with_states',
                                                                                        'relax/legacy/trainer.py')},
            'relax.legacy.utils': { 'relax.legacy.utils.Config': ('legacy/utils.html#config', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.Config.default': ('legacy/utils.html#config.default', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.accuracy': ('legacy/utils.html#accuracy', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.binary_cross_entropy': ( 'legacy/utils.html#binary_cross_entropy',
                                                                                 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.cat_normalize': ('legacy/utils.html#cat_normalize', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.check_cat_info': ('legacy/utils.html#check_cat_info', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.dist': ('legacy/utils.html#dist', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.get_config': ('legacy/utils.html#get_config', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.grad_update': ('legacy/utils.html#grad_update', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.init_net_opt': ('legacy/utils.html#init_net_opt', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.load_json': ('legacy/utils.html#load_json', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.make_hk_module': ('legacy/utils.html#make_hk_module', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.make_model': ('legacy/utils.html#make_model', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.proximity': ('legacy/utils.html#proximity', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.sigmoid': ('legacy/utils.html#sigmoid', 'relax/legacy/utils.py'),
                                    'relax.legacy.utils.validate_configs': ('legacy/utils.html#validate_configs', 'relax/legacy/utils.py')},
            'relax.methods.base': { 'relax.methods.base.CFModule': ('methods/base.html#cfmodule', 'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.__init__': ( 'methods/base.html#cfmodule.__init__',
                                                                              'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.apply_constraints': ( 'methods/base.html#cfmodule.apply_constraints',
                                                                                       'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.before_generate_cf': ( 'methods/base.html#cfmodule.before_generate_cf',
                                                                                        'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.compute_reg_loss': ( 'methods/base.html#cfmodule.compute_reg_loss',
                                                                                      'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.generate_cf': ( 'methods/base.html#cfmodule.generate_cf',
                                                                                 'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.set_apply_constraints_fn': ( 'methods/base.html#cfmodule.set_apply_constraints_fn',
                                                                                              'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.set_compute_reg_loss_fn': ( 'methods/base.html#cfmodule.set_compute_reg_loss_fn',
                                                                                             'relax/methods/base.py'),
                                    'relax.methods.base.CFModule.set_data_module': ( 'methods/base.html#cfmodule.set_data_module',
                                                                                     'relax/methods/base.py'),
                                    'relax.methods.base.ParametricCFModule': ( 'methods/base.html#parametriccfmodule',
                                                                               'relax/methods/base.py'),
                                    'relax.methods.base.ParametricCFModule.train': ( 'methods/base.html#parametriccfmodule.train',
                                                                                     'relax/methods/base.py'),
                                    'relax.methods.base.default_apply_constraints_fn': ( 'methods/base.html#default_apply_constraints_fn',
                                                                                         'relax/methods/base.py'),
                                    'relax.methods.base.default_compute_reg_loss_fn': ( 'methods/base.html#default_compute_reg_loss_fn',
                                                                                        'relax/methods/base.py')},
            'relax.methods.cchvae': { 'relax.methods.cchvae.CCHVAE': ('methods/cchvae.html#cchvae', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CCHVAE.__init__': ( 'methods/cchvae.html#cchvae.__init__',
                                                                                'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CCHVAE._init_model': ( 'methods/cchvae.html#cchvae._init_model',
                                                                                   'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CCHVAE.generate_cf': ( 'methods/cchvae.html#cchvae.generate_cf',
                                                                                   'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CCHVAE.train': ('methods/cchvae.html#cchvae.train', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CCHVAEConfig': ('methods/cchvae.html#cchvaeconfig', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE': ('methods/cchvae.html#chvae', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.__init__': ( 'methods/cchvae.html#chvae.__init__',
                                                                               'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.build': ('methods/cchvae.html#chvae.build', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.call': ('methods/cchvae.html#chvae.call', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.compute_kl_loss': ( 'methods/cchvae.html#chvae.compute_kl_loss',
                                                                                      'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.decode': ('methods/cchvae.html#chvae.decode', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.encode': ('methods/cchvae.html#chvae.encode', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.forward': ( 'methods/cchvae.html#chvae.forward',
                                                                              'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.regenerate': ( 'methods/cchvae.html#chvae.regenerate',
                                                                                 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.reparameterize': ( 'methods/cchvae.html#chvae.reparameterize',
                                                                                     'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae.CHVAE.set_apply_constraints_fn': ( 'methods/cchvae.html#chvae.set_apply_constraints_fn',
                                                                                               'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae._cchvae': ('methods/cchvae.html#_cchvae', 'relax/methods/cchvae.py'),
                                      'relax.methods.cchvae._hyper_sphere_coordindates': ( 'methods/cchvae.html#_hyper_sphere_coordindates',
                                                                                           'relax/methods/cchvae.py')},
            'relax.methods.clue': { 'relax.methods.clue.CLUE': ('methods/clue.html#clue', 'relax/methods/clue.py'),
                                    'relax.methods.clue.CLUE.__init__': ('methods/clue.html#clue.__init__', 'relax/methods/clue.py'),
                                    'relax.methods.clue.CLUE._init_model': ('methods/clue.html#clue._init_model', 'relax/methods/clue.py'),
                                    'relax.methods.clue.CLUE.generate_cf': ('methods/clue.html#clue.generate_cf', 'relax/methods/clue.py'),
                                    'relax.methods.clue.CLUE.train': ('methods/clue.html#clue.train', 'relax/methods/clue.py'),
                                    'relax.methods.clue.CLUEConfig': ('methods/clue.html#clueconfig', 'relax/methods/clue.py'),
                                    'relax.methods.clue.Decoder': ('methods/clue.html#decoder', 'relax/methods/clue.py'),
                                    'relax.methods.clue.Decoder.__call__': ('methods/clue.html#decoder.__call__', 'relax/methods/clue.py'),
                                    'relax.methods.clue.Decoder.__init__': ('methods/clue.html#decoder.__init__', 'relax/methods/clue.py'),
                                    'relax.methods.clue.Encoder': ('methods/clue.html#encoder', 'relax/methods/clue.py'),
                                    'relax.methods.clue.Encoder.__init__': ('methods/clue.html#encoder.__init__', 'relax/methods/clue.py'),
                                    'relax.methods.clue.Encoder.call': ('methods/clue.html#encoder.call', 'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat': ('methods/clue.html#vaegausscat', 'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.__init__': ( 'methods/clue.html#vaegausscat.__init__',
                                                                                 'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.build': ( 'methods/clue.html#vaegausscat.build',
                                                                              'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.call': ('methods/clue.html#vaegausscat.call', 'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.compute_vae_loss': ( 'methods/clue.html#vaegausscat.compute_vae_loss',
                                                                                         'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.decode': ( 'methods/clue.html#vaegausscat.decode',
                                                                               'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.encode': ( 'methods/clue.html#vaegausscat.encode',
                                                                               'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.sample': ( 'methods/clue.html#vaegausscat.sample',
                                                                               'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.sample_latent': ( 'methods/clue.html#vaegausscat.sample_latent',
                                                                                      'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.sample_step': ( 'methods/clue.html#vaegausscat.sample_step',
                                                                                    'relax/methods/clue.py'),
                                    'relax.methods.clue.VAEGaussCat.set_reconstruction_loss': ( 'methods/clue.html#vaegausscat.set_reconstruction_loss',
                                                                                                'relax/methods/clue.py'),
                                    'relax.methods.clue._clue_generate': ('methods/clue.html#_clue_generate', 'relax/methods/clue.py'),
                                    'relax.methods.clue.get_reconstruction_loss_fn': ( 'methods/clue.html#get_reconstruction_loss_fn',
                                                                                       'relax/methods/clue.py'),
                                    'relax.methods.clue.kl_divergence': ('methods/clue.html#kl_divergence', 'relax/methods/clue.py')},
            'relax.methods.counternet': { 'relax.methods.counternet.CounterNet': ( 'methods/counternet.html#counternet',
                                                                                   'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNet.__init__': ( 'methods/counternet.html#counternet.__init__',
                                                                                            'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNet._init_model': ( 'methods/counternet.html#counternet._init_model',
                                                                                               'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNet.generate_cf': ( 'methods/counternet.html#counternet.generate_cf',
                                                                                               'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNet.is_trained': ( 'methods/counternet.html#counternet.is_trained',
                                                                                              'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNet.pred_fn': ( 'methods/counternet.html#counternet.pred_fn',
                                                                                           'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNet.train': ( 'methods/counternet.html#counternet.train',
                                                                                         'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetConfig': ( 'methods/counternet.html#counternetconfig',
                                                                                         'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetModel': ( 'methods/counternet.html#counternetmodel',
                                                                                        'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetModel.__call__': ( 'methods/counternet.html#counternetmodel.__call__',
                                                                                                 'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetModel.__init__': ( 'methods/counternet.html#counternetmodel.__init__',
                                                                                                 'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule': ( 'methods/counternet.html#counternettrainingmodule',
                                                                                                 'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.__init__': ( 'methods/counternet.html#counternettrainingmodule.__init__',
                                                                                                          'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule._explainer_step': ( 'methods/counternet.html#counternettrainingmodule._explainer_step',
                                                                                                                 'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule._predictor_step': ( 'methods/counternet.html#counternettrainingmodule._predictor_step',
                                                                                                                 'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule._training_step': ( 'methods/counternet.html#counternettrainingmodule._training_step',
                                                                                                                'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule._training_step_logs': ( 'methods/counternet.html#counternettrainingmodule._training_step_logs',
                                                                                                                     'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.exp_loss_fn': ( 'methods/counternet.html#counternettrainingmodule.exp_loss_fn',
                                                                                                             'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.forward': ( 'methods/counternet.html#counternettrainingmodule.forward',
                                                                                                         'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.generate_cf': ( 'methods/counternet.html#counternettrainingmodule.generate_cf',
                                                                                                             'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.init_net_opt': ( 'methods/counternet.html#counternettrainingmodule.init_net_opt',
                                                                                                              'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.loss_fn_1': ( 'methods/counternet.html#counternettrainingmodule.loss_fn_1',
                                                                                                           'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.loss_fn_2': ( 'methods/counternet.html#counternettrainingmodule.loss_fn_2',
                                                                                                           'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.loss_fn_3': ( 'methods/counternet.html#counternettrainingmodule.loss_fn_3',
                                                                                                           'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.pred_fn': ( 'methods/counternet.html#counternettrainingmodule.pred_fn',
                                                                                                         'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.pred_loss_fn': ( 'methods/counternet.html#counternettrainingmodule.pred_loss_fn',
                                                                                                              'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.training_step': ( 'methods/counternet.html#counternettrainingmodule.training_step',
                                                                                                               'relax/methods/counternet.py'),
                                          'relax.methods.counternet.CounterNetTrainingModule.validation_step': ( 'methods/counternet.html#counternettrainingmodule.validation_step',
                                                                                                                 'relax/methods/counternet.py'),
                                          'relax.methods.counternet.partition_trainable_params': ( 'methods/counternet.html#partition_trainable_params',
                                                                                                   'relax/methods/counternet.py')},
            'relax.methods.dice': { 'relax.methods.dice.DiverseCF': ('methods/dice.html#diversecf', 'relax/methods/dice.py'),
                                    'relax.methods.dice.DiverseCF.__init__': ( 'methods/dice.html#diversecf.__init__',
                                                                               'relax/methods/dice.py'),
                                    'relax.methods.dice.DiverseCF.generate_cf': ( 'methods/dice.html#diversecf.generate_cf',
                                                                                  'relax/methods/dice.py'),
                                    'relax.methods.dice.DiverseCF.load_from_path': ( 'methods/dice.html#diversecf.load_from_path',
                                                                                     'relax/methods/dice.py'),
                                    'relax.methods.dice.DiverseCF.save': ('methods/dice.html#diversecf.save', 'relax/methods/dice.py'),
                                    'relax.methods.dice.DiverseCFConfig': ('methods/dice.html#diversecfconfig', 'relax/methods/dice.py'),
                                    'relax.methods.dice._diverse_cf': ('methods/dice.html#_diverse_cf', 'relax/methods/dice.py'),
                                    'relax.methods.dice.dpp_style_vmap': ('methods/dice.html#dpp_style_vmap', 'relax/methods/dice.py')},
            'relax.methods.l2c': { 'relax.methods.l2c.Discretizer': ('methods/l2c.html#discretizer', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.__init__': ( 'methods/l2c.html#discretizer.__init__',
                                                                               'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.fit': ('methods/l2c.html#discretizer.fit', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.fit_transform': ( 'methods/l2c.html#discretizer.fit_transform',
                                                                                    'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.get_pred_fn': ( 'methods/l2c.html#discretizer.get_pred_fn',
                                                                                  'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.inverse_transform': ( 'methods/l2c.html#discretizer.inverse_transform',
                                                                                        'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.inverse_transform_indices': ( 'methods/l2c.html#discretizer.inverse_transform_indices',
                                                                                                'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.inversed_transform_pytree': ( 'methods/l2c.html#discretizer.inversed_transform_pytree',
                                                                                                'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.transform': ( 'methods/l2c.html#discretizer.transform',
                                                                                'relax/methods/l2c.py'),
                                   'relax.methods.l2c.Discretizer.transform_indices': ( 'methods/l2c.html#discretizer.transform_indices',
                                                                                        'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2C': ('methods/l2c.html#l2c', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2C.__init__': ('methods/l2c.html#l2c.__init__', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2C.generate_cf': ('methods/l2c.html#l2c.generate_cf', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2C.train': ('methods/l2c.html#l2c.train', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CConfig': ('methods/l2c.html#l2cconfig', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel': ('methods/l2c.html#l2cmodel', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.__init__': ('methods/l2c.html#l2cmodel.__init__', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.build': ('methods/l2c.html#l2cmodel.build', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.call': ('methods/l2c.html#l2cmodel.call', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.compute_l2c_loss': ( 'methods/l2c.html#l2cmodel.compute_l2c_loss',
                                                                                    'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.forward': ('methods/l2c.html#l2cmodel.forward', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.set_features_info': ( 'methods/l2c.html#l2cmodel.set_features_info',
                                                                                     'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.set_immutable_mask': ( 'methods/l2c.html#l2cmodel.set_immutable_mask',
                                                                                      'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.set_pred_fn': ( 'methods/l2c.html#l2cmodel.set_pred_fn',
                                                                               'relax/methods/l2c.py'),
                                   'relax.methods.l2c.L2CModel.start_end_indices': ( 'methods/l2c.html#l2cmodel.start_end_indices',
                                                                                     'relax/methods/l2c.py'),
                                   'relax.methods.l2c.cut_quantiles': ('methods/l2c.html#cut_quantiles', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.discretize_xs': ('methods/l2c.html#discretize_xs', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.gumbel_softmax': ('methods/l2c.html#gumbel_softmax', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.qcut': ('methods/l2c.html#qcut', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.qcut_inverse': ('methods/l2c.html#qcut_inverse', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.sample_bernouli': ('methods/l2c.html#sample_bernouli', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.sample_categorical': ('methods/l2c.html#sample_categorical', 'relax/methods/l2c.py'),
                                   'relax.methods.l2c.split_fn': ('methods/l2c.html#split_fn', 'relax/methods/l2c.py')},
            'relax.methods.proto': { 'relax.methods.proto.ProtoCF': ('methods/proto.html#protocf', 'relax/methods/proto.py'),
                                     'relax.methods.proto.ProtoCF.__init__': ( 'methods/proto.html#protocf.__init__',
                                                                               'relax/methods/proto.py'),
                                     'relax.methods.proto.ProtoCF._init_model': ( 'methods/proto.html#protocf._init_model',
                                                                                  'relax/methods/proto.py'),
                                     'relax.methods.proto.ProtoCF.generate_cf': ( 'methods/proto.html#protocf.generate_cf',
                                                                                  'relax/methods/proto.py'),
                                     'relax.methods.proto.ProtoCF.train': ('methods/proto.html#protocf.train', 'relax/methods/proto.py'),
                                     'relax.methods.proto.ProtoCFConfig': ('methods/proto.html#protocfconfig', 'relax/methods/proto.py'),
                                     'relax.methods.proto._proto_cf': ('methods/proto.html#_proto_cf', 'relax/methods/proto.py')},
            'relax.methods.sphere': { 'relax.methods.sphere.GSConfig': ('methods/sphere.html#gsconfig', 'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere': ( 'methods/sphere.html#growingsphere',
                                                                              'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere.__init__': ( 'methods/sphere.html#growingsphere.__init__',
                                                                                       'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere.before_generate_cf': ( 'methods/sphere.html#growingsphere.before_generate_cf',
                                                                                                 'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere.generate_cf': ( 'methods/sphere.html#growingsphere.generate_cf',
                                                                                          'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere.has_data_module': ( 'methods/sphere.html#growingsphere.has_data_module',
                                                                                              'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere.load_from_path': ( 'methods/sphere.html#growingsphere.load_from_path',
                                                                                             'relax/methods/sphere.py'),
                                      'relax.methods.sphere.GrowingSphere.save': ( 'methods/sphere.html#growingsphere.save',
                                                                                   'relax/methods/sphere.py'),
                                      'relax.methods.sphere._growing_spheres': ( 'methods/sphere.html#_growing_spheres',
                                                                                 'relax/methods/sphere.py'),
                                      'relax.methods.sphere.cat_perturb_fn': ( 'methods/sphere.html#cat_perturb_fn',
                                                                               'relax/methods/sphere.py'),
                                      'relax.methods.sphere.default_perturb_function': ( 'methods/sphere.html#default_perturb_function',
                                                                                         'relax/methods/sphere.py'),
                                      'relax.methods.sphere.features_to_infos_and_perturb_fn': ( 'methods/sphere.html#features_to_infos_and_perturb_fn',
                                                                                                 'relax/methods/sphere.py'),
                                      'relax.methods.sphere.hyper_sphere_coordindates': ( 'methods/sphere.html#hyper_sphere_coordindates',
                                                                                          'relax/methods/sphere.py'),
                                      'relax.methods.sphere.perturb_function_with_features': ( 'methods/sphere.html#perturb_function_with_features',
                                                                                               'relax/methods/sphere.py'),
                                      'relax.methods.sphere.sample_categorical': ( 'methods/sphere.html#sample_categorical',
                                                                                   'relax/methods/sphere.py')},
            'relax.methods.vaecf': { 'relax.methods.vaecf.VAE': ('methods/vaecf.html#vae', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.__init__': ('methods/vaecf.html#vae.__init__', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE._compile': ('methods/vaecf.html#vae._compile', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.build': ('methods/vaecf.html#vae.build', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.call': ('methods/vaecf.html#vae.call', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.compute_vae_loss': ( 'methods/vaecf.html#vae.compute_vae_loss',
                                                                                   'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.decode': ('methods/vaecf.html#vae.decode', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.encode': ('methods/vaecf.html#vae.encode', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.sample': ('methods/vaecf.html#vae.sample', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.set_compute_regularization_fn': ( 'methods/vaecf.html#vae.set_compute_regularization_fn',
                                                                                                'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAE.set_pred_fn': ( 'methods/vaecf.html#vae.set_pred_fn',
                                                                              'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAECF': ('methods/vaecf.html#vaecf', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAECF.__init__': ('methods/vaecf.html#vaecf.__init__', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAECF._init_model': ( 'methods/vaecf.html#vaecf._init_model',
                                                                                'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAECF.generate_cf': ( 'methods/vaecf.html#vaecf.generate_cf',
                                                                                'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAECF.train': ('methods/vaecf.html#vaecf.train', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.VAECFConfig': ('methods/vaecf.html#vaecfconfig', 'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.hindge_embedding_loss': ( 'methods/vaecf.html#hindge_embedding_loss',
                                                                                    'relax/methods/vaecf.py'),
                                     'relax.methods.vaecf.sample_latent': ('methods/vaecf.html#sample_latent', 'relax/methods/vaecf.py')},
            'relax.methods.vanilla': { 'relax.methods.vanilla.VanillaCF': ('methods/vanilla.html#vanillacf', 'relax/methods/vanilla.py'),
                                       'relax.methods.vanilla.VanillaCF.__init__': ( 'methods/vanilla.html#vanillacf.__init__',
                                                                                     'relax/methods/vanilla.py'),
                                       'relax.methods.vanilla.VanillaCF.generate_cf': ( 'methods/vanilla.html#vanillacf.generate_cf',
                                                                                        'relax/methods/vanilla.py'),
                                       'relax.methods.vanilla.VanillaCF.load_from_path': ( 'methods/vanilla.html#vanillacf.load_from_path',
                                                                                           'relax/methods/vanilla.py'),
                                       'relax.methods.vanilla.VanillaCF.save': ( 'methods/vanilla.html#vanillacf.save',
                                                                                 'relax/methods/vanilla.py'),
                                       'relax.methods.vanilla.VanillaCFConfig': ( 'methods/vanilla.html#vanillacfconfig',
                                                                                  'relax/methods/vanilla.py'),
                                       'relax.methods.vanilla._vanilla_cf': ( 'methods/vanilla.html#_vanilla_cf',
                                                                              'relax/methods/vanilla.py')},
            'relax.ml_model': { 'relax.ml_model.AutoEncoder': ('ml_model.html#autoencoder', 'relax/ml_model.py'),
                                'relax.ml_model.AutoEncoder.__init__': ('ml_model.html#autoencoder.__init__', 'relax/ml_model.py'),
                                'relax.ml_model.AutoEncoder.call': ('ml_model.html#autoencoder.call', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule': ('ml_model.html#mlmodule', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule.__init__': ('ml_model.html#mlmodule.__init__', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule._init_model': ('ml_model.html#mlmodule._init_model', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule.is_trained': ('ml_model.html#mlmodule.is_trained', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule.load_from_path': ('ml_model.html#mlmodule.load_from_path', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule.pred_fn': ('ml_model.html#mlmodule.pred_fn', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule.save': ('ml_model.html#mlmodule.save', 'relax/ml_model.py'),
                                'relax.ml_model.MLModule.train': ('ml_model.html#mlmodule.train', 'relax/ml_model.py'),
                                'relax.ml_model.MLModuleConfig': ('ml_model.html#mlmoduleconfig', 'relax/ml_model.py'),
                                'relax.ml_model.MLP': ('ml_model.html#mlp', 'relax/ml_model.py'),
                                'relax.ml_model.MLP.__init__': ('ml_model.html#mlp.__init__', 'relax/ml_model.py'),
                                'relax.ml_model.MLP.call': ('ml_model.html#mlp.call', 'relax/ml_model.py'),
                                'relax.ml_model.MLP.get_config': ('ml_model.html#mlp.get_config', 'relax/ml_model.py'),
                                'relax.ml_model.MLPBlock': ('ml_model.html#mlpblock', 'relax/ml_model.py'),
                                'relax.ml_model.MLPBlock.__init__': ('ml_model.html#mlpblock.__init__', 'relax/ml_model.py'),
                                'relax.ml_model.MLPBlock.build': ('ml_model.html#mlpblock.build', 'relax/ml_model.py'),
                                'relax.ml_model.MLPBlock.call': ('ml_model.html#mlpblock.call', 'relax/ml_model.py'),
                                'relax.ml_model.download_ml_module': ('ml_model.html#download_ml_module', 'relax/ml_model.py'),
                                'relax.ml_model.load_ml_module': ('ml_model.html#load_ml_module', 'relax/ml_model.py')},
            'relax.strategy': { 'relax.strategy.BaseStrategy': ('explain.strategy.html#basestrategy', 'relax/strategy.py'),
                                'relax.strategy.BaseStrategy.__call__': ( 'explain.strategy.html#basestrategy.__call__',
                                                                          'relax/strategy.py'),
                                'relax.strategy.BatchedPmapStrategy': ('explain.strategy.html#batchedpmapstrategy', 'relax/strategy.py'),
                                'relax.strategy.BatchedPmapStrategy.__call__': ( 'explain.strategy.html#batchedpmapstrategy.__call__',
                                                                                 'relax/strategy.py'),
                                'relax.strategy.BatchedPmapStrategy.__init__': ( 'explain.strategy.html#batchedpmapstrategy.__init__',
                                                                                 'relax/strategy.py'),
                                'relax.strategy.BatchedVmapStrategy': ('explain.strategy.html#batchedvmapstrategy', 'relax/strategy.py'),
                                'relax.strategy.BatchedVmapStrategy.__call__': ( 'explain.strategy.html#batchedvmapstrategy.__call__',
                                                                                 'relax/strategy.py'),
                                'relax.strategy.BatchedVmapStrategy.__init__': ( 'explain.strategy.html#batchedvmapstrategy.__init__',
                                                                                 'relax/strategy.py'),
                                'relax.strategy.IterativeStrategy': ('explain.strategy.html#iterativestrategy', 'relax/strategy.py'),
                                'relax.strategy.IterativeStrategy.__call__': ( 'explain.strategy.html#iterativestrategy.__call__',
                                                                               'relax/strategy.py'),
                                'relax.strategy.PmapStrategy': ('explain.strategy.html#pmapstrategy', 'relax/strategy.py'),
                                'relax.strategy.PmapStrategy.__call__': ( 'explain.strategy.html#pmapstrategy.__call__',
                                                                          'relax/strategy.py'),
                                'relax.strategy.PmapStrategy.__init__': ( 'explain.strategy.html#pmapstrategy.__init__',
                                                                          'relax/strategy.py'),
                                'relax.strategy.StrategyFactory': ('explain.strategy.html#strategyfactory', 'relax/strategy.py'),
                                'relax.strategy.StrategyFactory.__init__': ( 'explain.strategy.html#strategyfactory.__init__',
                                                                             'relax/strategy.py'),
                                'relax.strategy.StrategyFactory.get_default_strategy': ( 'explain.strategy.html#strategyfactory.get_default_strategy',
                                                                                         'relax/strategy.py'),
                                'relax.strategy.StrategyFactory.get_strategy': ( 'explain.strategy.html#strategyfactory.get_strategy',
                                                                                 'relax/strategy.py'),
                                'relax.strategy.VmapStrategy': ('explain.strategy.html#vmapstrategy', 'relax/strategy.py'),
                                'relax.strategy.VmapStrategy.__call__': ( 'explain.strategy.html#vmapstrategy.__call__',
                                                                          'relax/strategy.py'),
                                'relax.strategy._batched_generation': ('explain.strategy.html#_batched_generation', 'relax/strategy.py'),
                                'relax.strategy._pad_divisible_X': ('explain.strategy.html#_pad_divisible_x', 'relax/strategy.py'),
                                'relax.strategy._pad_xs': ('explain.strategy.html#_pad_xs', 'relax/strategy.py')},
            'relax.utils': { 'relax.utils.Config': ('utils.html#config', 'relax/utils.py'),
                             'relax.utils.Config.default': ('utils.html#config.default', 'relax/utils.py'),
                             'relax.utils._is_array': ('utils.html#_is_array', 'relax/utils.py'),
                             'relax.utils._reshape_x': ('utils.html#_reshape_x', 'relax/utils.py'),
                             'relax.utils.auto_reshaping': ('utils.html#auto_reshaping', 'relax/utils.py'),
                             'relax.utils.get_config': ('utils.html#get_config', 'relax/utils.py'),
                             'relax.utils.grad_update': ('utils.html#grad_update', 'relax/utils.py'),
                             'relax.utils.gumbel_softmax': ('utils.html#gumbel_softmax', 'relax/utils.py'),
                             'relax.utils.load_json': ('utils.html#load_json', 'relax/utils.py'),
                             'relax.utils.load_pytree': ('utils.html#load_pytree', 'relax/utils.py'),
                             'relax.utils.save_pytree': ('utils.html#save_pytree', 'relax/utils.py'),
                             'relax.utils.set_config': ('utils.html#set_config', 'relax/utils.py'),
                             'relax.utils.validate_configs': ('utils.html#validate_configs', 'relax/utils.py')}}}
