feature/latent samples

autofit/__init__.py

@@ -64,9 +64,9 @@
 from .mapper.prior_model.prior_model import Model
 from .mapper.prior_model.util import PriorModelNameValue
 from .non_linear.search.abstract_search import NonLinearSearch
+from .non_linear.analysis.visualize import Visualizer
 from .non_linear.analysis.analysis import Analysis
 from .non_linear.analysis.combined import CombinedAnalysis
-from .non_linear.analysis.latent_variables import LatentVariables
 from .non_linear.grid.grid_search import GridSearchResult
 from .non_linear.grid.sensitivity import Sensitivity
 from .non_linear.initializer import InitializerBall

autofit/aggregator/search_output.py

@@ -4,7 +4,7 @@
 import pickle
 from os import path
 from pathlib import Path
-from typing import Generator, Tuple, Optional, List, cast
+from typing import Generator, Tuple, Optional, List, cast, Type
 
 import dill
 
@@ -21,6 +21,7 @@
 from autofit.non_linear.samples.sample import samples_from_iterator
 from autoconf.dictable import from_dict
 from autofit.non_linear.samples.summary import SamplesSummary
+from autofit.non_linear.samples.util import simple_model_for_kwargs
 
 # noinspection PyProtectedMember
 original_create_file_handle = dill._dill._create_filehandle
@@ -178,6 +179,7 @@ def __init__(self, directory: Path, reference: dict = None):
         self.__search = None
         self.__model = None
         self._samples = None
+        self._latent_samples = None
 
         self.directory = directory
 
@@ -200,7 +202,9 @@ def samples_summary(self) -> SamplesSummary:
 
         This is loaded from a JSON file.
         """
-        return self.value("samples_summary")
+        summary = self.value("samples_summary")
+        summary.model = self.model
+        return summary
 
     @property
     def instance(self):
@@ -240,36 +244,49 @@ def samples(self) -> SamplesPDF:
         and a JSON containing metadata.
         """
         if not self._samples:
-            try:
-                info_json = JSONOutput(
-                    "info", self.files_path / "samples_info.json"
-                ).dict
-
-                with open(self.files_path / "samples.csv") as f:
-                    sample_list = samples_from_iterator(csv.reader(f))
-
-                cls = cast(Samples, get_class(info_json["class_path"]))
-
-                self._samples = cls.from_list_info_and_model(
-                    sample_list=sample_list,
-                    samples_info=info_json,
-                    model=self.model,
-                )
-            except FileNotFoundError:
-                raise AttributeError("No samples found")
+            self._samples = self._load_samples(
+                model=self.model,
+            )
         return self._samples
 
     @property
-    def latent_variables(self):
+    def latent_samples(self):
         """
         The latent variables of the search, parsed from a CSV file.
         """
-        with open(self.files_path / "latent.csv") as f:
-            reader = csv.reader(f)
-            headers = next(reader)
-            from autofit.non_linear.analysis.latent_variables import LatentVariables
+        if not self._latent_samples:
+            self._latent_samples = self._load_samples("latent")
+        return self._latent_samples
+
+    def _load_samples(self, name=None, model=None):
+        if name:
+            directory = self.files_path / name
+        else:
+            directory = self.files_path
+        try:
+            info_json = JSONOutput("info", directory / "samples_info.json").dict
+
+            with open(directory / "samples.csv") as f:
+                sample_list = samples_from_iterator(csv.reader(f))
 
-            return LatentVariables(headers, [list(map(float, row)) for row in reader])
+            if model is None:
+                try:
+                    model = simple_model_for_kwargs(sample_list[0].kwargs)
+                except IndexError:
+                    model = None
+
+            cls = cast(
+                Type[Samples],
+                get_class(info_json["class_path"]),
+            )
+
+            return cls.from_list_info_and_model(
+                sample_list=sample_list,
+                samples_info=info_json,
+                model=model,
+            )
+        except FileNotFoundError:
+            raise AttributeError(f"No {name} found")
 
     def names_and_paths(
         self,

autofit/config/output.yaml

@@ -88,6 +88,4 @@ covariance: true # `covariance.csv`: The [free parameters x free parameters] cov
 data: true # `data.json`: The value of every data point in the data.
 noise_map: true # `noise_map.json`: The value of every RMS noise map value.
 
-search_log: true # `search.log`: logging produced whilst running the fit or fit_sequential method
-
-default: false
+search_log: true # `search.log`: logging produced whilst running the fit or fit_sequential method

autofit/database/aggregator/scrape.py

@@ -153,8 +153,8 @@ def _add_files_fit(fit: m.Fit, item: SearchOutput):
     except AttributeError:
         logger.warning(f"Failed to load samples for {fit.id}")
     try:
-        fit.latent_variables = item.latent_variables
-    except FileNotFoundError:
+        fit.latent_samples = item.latent_samples
+    except AttributeError:
         logger.warning(f"Failed to load latent variables for {fit.id}")
 
     _add_files(fit, item)
@@ -176,7 +176,7 @@ def _add_files(fit: m.Fit, item: SearchOutput):
         fit.set_pickle(pickle_output.name, pickle_output.value)
 
     for array_output in item.arrays:
-        if array_output.name in ("samples", "latent_variables"):
+        if array_output.name in ("samples", "latent_samples"):
             continue
         try:
             fit.set_array(array_output.name, array_output.value)

autofit/database/migration/steps.py

@@ -20,6 +20,9 @@
     Step(
         "ALTER TABLE object ADD COLUMN latent_variables_for_id INTEGER;",
     ),
+    Step(
+        "ALTER TABLE object RENAME COLUMN latent_variables_for_id TO latent_samples_for_id;",
+    ),
 ]
 
 migrator = Migrator(*steps)

autofit/database/model/fit.py

@@ -256,8 +256,8 @@ def best_fit(self) -> "Fit":
     _samples = sa.orm.relationship(
         Object, uselist=False, foreign_keys=[Object.samples_for_id]
     )
-    _latent_variables = sa.orm.relationship(
-        Object, uselist=False, foreign_keys=[Object.latent_variables_for_id]
+    _latent_samples = sa.orm.relationship(
+        Object, uselist=False, foreign_keys=[Object.latent_samples_for_id]
     )
 
     @property
@@ -273,12 +273,12 @@ def samples(self, samples):
 
     @property
     @try_none
-    def latent_variables(self) -> dict:
-        return self._latent_variables()
+    def latent_samples(self) -> dict:
+        return self._latent_samples()
 
-    @latent_variables.setter
-    def latent_variables(self, latent_variables):
-        self._latent_variables = Object.from_object(latent_variables.efficient())
+    @latent_samples.setter
+    def latent_samples(self, latent_samples):
+        self._latent_samples = Object.from_object(latent_samples.minimise())
 
     @property
     def info(self):

autofit/database/model/model.py

@@ -35,9 +35,11 @@ class Object(Base):
         "Fit", uselist=False, foreign_keys=[samples_for_id]
     )
 
-    latent_variables_for_id = sa.Column(sa.String, sa.ForeignKey("fit.id"))
-    latent_variables_for = sa.orm.relationship(
-        "Fit", uselist=False, foreign_keys=[latent_variables_for_id]
+    latent_samples_for_id = sa.Column(sa.String, sa.ForeignKey("fit.id"))
+    latent_samples_for = sa.orm.relationship(
+        "Fit",
+        uselist=False,
+        foreign_keys=[latent_samples_for_id],
     )
 
     children: List["Object"] = sa.orm.relationship(