Latent to pdf

configs/cascade_11param_noise_ftpv3m.yaml

@@ -281,7 +281,7 @@ loss_module_settings: [
 
         config: {
             # the float precision to use
-            'float_precision': 'float64',
+            'float_precision': 'float32',
             # Add normalization terms to llh if True
             'add_normalization_term': True,
             # choose the loss function to use
@@ -295,49 +295,35 @@ loss_module_settings: [
 
         config: {
             # the float precision to use
-            'float_precision': 'float64',
+            'float_precision': 'float32',
             # Add normalization terms to llh if True
             'add_normalization_term': True,
             # choose the loss function to use
-            'loss_function_name': 'normalized_dom_charge_pdf',
-        },
-    },
-    {
-        # The loss module class to use
-        'loss_module': 'egenerator.loss.default.DefaultLossModule',
-        'loss_module_weight': 1.0,
-
-        config: {
-            # the float precision to use
-            'float_precision': 'float64',
-            # Add normalization terms to llh if True
-            'add_normalization_term': True,
-            # choose the loss function to use
-            'loss_function_name': 'negative_binomial_charge_pdf',
-        },
-    },
-    {
-        # The loss module class to use
-        'loss_module': 'egenerator.loss.default.DefaultLossModule',
-        'loss_module_weight': 1.0,
-
-        config: {
-            # the float precision to use
-            'float_precision': 'float64',
-            # Add normalization terms to llh if True
-            'add_normalization_term': True,
-            # choose the loss function to use
-            'loss_function_name': 'negative_binomial_event_charge_pdf',
+            'loss_function_name': 'dom_charge_pdf',
         },
     },
+    # {
+    #     # The loss module class to use
+    #     'loss_module': 'egenerator.loss.default.DefaultLossModule',
+    #     'loss_module_weight': 1.0,
+
+    #     config: {
+    #         # the float precision to use
+    #         'float_precision': 'float32',
+    #         # Add normalization terms to llh if True
+    #         'add_normalization_term': True,
+    #         # choose the loss function to use
+    #         'loss_function_name': 'negative_binomial_charge_pdf',
+    #     },
+    # },
     {
         # The loss module class to use
         'loss_module': 'egenerator.loss.snowstorm.SnowstormPriorLossModule',
         'loss_module_weight': 1.0,
 
         config: {
             # the float precision to use
-            'float_precision': 'float64',
+            'float_precision': 'float32',
             # define uniform priors
             'uniform_parameters': {
                 'cascade_Absorption': [0.913, 1.087],
@@ -470,6 +456,7 @@ model_settings: {
 
     # configuration settings for DefaultMultiCascadeModel object
     config: {
+        'float_precision': float32,
         'sources': {
             'noise': 'noise',
             'cascade': 'cascade',
@@ -482,7 +469,77 @@ model_settings: {
         noise: {
             # The noise source model class to use
             'model_class': 'egenerator.model.source.noise.default.DefaultNoiseModel',
-            config: {'float_precision': float32},
+
+            config: {
+                'float_precision': float32,
+                'num_local_vars': 9,
+
+                # define names of charge latent vars that should be
+                # scaled internally by the model (e.g. by the energy, eff.)
+                # Note: the decoder should not add additional value
+                # range mapping for these tensors!
+                'charge_scale_tensors': [
+                    "NegativeBinomial_mu_000",
+                    "NegativeBinomial_mu_001",
+                    "NegativeBinomial_mu_002",
+                ],
+            },
+
+            # configuration for the charge decoder to transform the latent
+            # variables to the expected charge PDF.
+            decoder_charge_settings: {
+
+                # The decoder class to use
+                decoder_class: "egenerator.model.decoder.mixture.MixtureModel",
+
+                # configuration of the mixture model
+                config: {
+                    # Note that mapping here will just repeat the names,
+                    # but in other cases it could be used to reuse the
+                    # same base model multiple times (as for MultiSource objects)
+                    "decoder_mapping": {
+                        "NegativeBinomial": ["NegativeBinomial", 3, 1.0],
+                    },
+
+                    # Define a mapping of latent variable to value range functions
+                    "value_range_mapping": {
+                        "weight": {
+                            "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                            "config": {
+                                "scale": 1.0,
+                                "offset": 1.0,
+                                "min_value": 0.000001
+                            },
+                        },
+                    },
+                },
+
+                # Define the decoder types that are used as components of the mixture
+                # model
+                base_decoders: {
+                    "NegativeBinomial": {
+                        # The decoder class to use
+                        decoder_class: "egenerator.model.decoder.NegativeBinomialDecoder",
+
+                        # configuration of the negative binomial model
+                        'config': {
+                            'float_precision': float32,
+
+                            # Define a mapping of latent variable to value range functions
+                            "value_range_mapping": {
+                                "alpha": {
+                                    "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                                    "config": {
+                                        "scale": 1.0,
+                                        "offset": -5.0,
+                                        "min_value": 0.0001,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
         },
 
         cascade: {
@@ -502,11 +559,14 @@ model_settings: {
                 'scale_charge_by_global_dom_efficiency': False,
                 'scale_charge_by_angular_acceptance': True,
                 'scale_charge_by_relative_angular_acceptance': False,
-                'prevent_mixture_component_swapping': False,
-                'charge_distribution_type': 'negative_binomial',
-                'num_latent_models': 10,
                 'float_precision': float32,
-                'float_precision_pdf_cdf': float64,
+                'mixture_component_t_seeds': [0, -100, 100, 8000, 4000, 800, 300, -50, -20, -10, -5, 0],
+
+                # define names of charge latent vars that should be
+                # scaled internally by the model (e.g. by the energy, eff.)
+                # Note: the decoder should not add additional value
+                # range mapping for these tensors!
+                'charge_scale_tensors': ["mu"],
 
                 # Baseline DOM Angular acceptance
                 'use_constant_baseline_hole_ice': False,
@@ -527,7 +587,7 @@ model_settings: {
 
                 # First convolutions
                 'filter_size_list' : [[1, 1], [1, 1], [1, 1], [1, 1], [1, 1], [1, 1]],
-                'num_filters_list' : [25, 100, 100, 100, 100, 42],
+                'num_filters_list' : [50, 100, 100, 100, 100, 45],
                 'method_list' : ['locally_connected',
                                  'convolution', 'convolution', 'convolution',
                                  'convolution', 'convolution',
@@ -537,6 +597,132 @@ model_settings: {
                 'use_batch_norm_list' : False,
                 'use_residual_list' : [True, True, True, True, True, False]
             },
+
+            # configuration for the charge decoder to transform the latent
+            # variables to the expected charge PDF.
+            decoder_charge_settings: {
+                # The decoder class to use
+                decoder_class: "egenerator.model.decoder.NegativeBinomialDecoder",
+
+                # configuration of the negative binomial model
+                'config': {
+                    'float_precision': float32,
+
+                    # Define a mapping of latent variable to value range functions
+                    "value_range_mapping": {
+                        "alpha": {
+                            "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                            "config": {
+                                "scale": 1.0,
+                                "offset": -5.0,
+                                "min_value": 0.0001,
+                            },
+                        },
+                    },
+                },
+            },
+
+            # configuration of the decoder to transform the latent variables
+            # to the time arrival PDF
+            decoder_settings: {
+
+                # The decoder class to use
+                decoder_class: "egenerator.model.decoder.mixture.MixtureModel",
+
+                # configuration of the mixture model
+                config: {
+                    # Note that mapping here will just repeat the names,
+                    # but in other cases it could be used to reuse the
+                    # same base model multiple times (as for MultiSource objects)
+                    "decoder_mapping": {
+                        "AssymetricGaussian": ["AssymetricGaussian", 7, 1.0],
+                        "GammaFunction": ["GammaFunction", 5, 10.0],
+                    },
+
+                    # Define a mapping of latent variable to value range functions
+                    "value_range_mapping": {
+                        "weight": {
+                            "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                            "config": {
+                                "scale": 1.0,
+                                "offset": 1.0,
+                                "min_value": 0.00001
+                            },
+                        },
+                    },
+                },
+
+                # Define the decoder types that are used as components of the mixture
+                # model
+                base_decoders: {
+                    AssymetricGaussian: {
+                        'decoder_class': 'egenerator.model.decoder.AsymmetricGaussianDecoder',
+                        'config': {
+                            'float_precision': float32,
+
+                            # Define a mapping of latent variable to value range functions
+                            "value_range_mapping": {
+                                "mu": {
+                                    "value_range_class": "egenerator.utils.value_range.BaseValueRange",
+                                    "config": {
+                                        "scale": 0.5,
+                                        "offset": 0.0,
+                                    },
+                                },
+                                "sigma": {
+                                    "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                                    "config": {
+                                        "scale": 1.0,
+                                        "offset": 2.0,
+                                        "min_value": 0.0001,
+                                    },
+                                },
+                                "r": {
+                                    "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                                    "config": {
+                                        "scale": 1.0,
+                                        "offset": 1.0,
+                                        "min_value": 0.0001,
+                                    },
+                                },
+                            },
+                        },
+
+                        # Define load_dir here if you want to load the model from a file
+                        # This does not make sense for a paremeter-less model, but it
+                        # could be used for a model that has been trained and saved
+                        # previously such as a normalizing flow model.
+                        # 'load_dir': 'path/to/model',
+                    },
+                    GammaFunction: {
+                        'decoder_class': 'egenerator.model.decoder.GammaFunctionDecoder',
+                        'config': {
+                            'float_precision': float32,
+                            'offset': 0.0, # note that offset is in model time units
+
+                            # Define a mapping of latent variable to value range functions
+                            "value_range_mapping": {
+                                "alpha": {
+                                    "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                                    "config": {
+                                        "scale": 0.3,
+                                        "offset": 2.5,
+                                        "min_value": 0.5,
+                                    },
+                                },
+                                "beta": {
+                                    "value_range_class": "egenerator.utils.value_range.EluValueRange",
+                                    "config": {
+                                        "scale": 1.0,
+                                        "offset": 10.0,
+                                        "min_value": 1.0,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
         },
     },
 }