workspace_index.json

[
  {
    "contents": [
      "Example: A simple example of an analysis class which can be adapted for you use-case.",
      "Customization: Customizing an analysis class with different data inputs and editing the `log_likelihood_function`.",
      "Visualization: Using a `visualize` method so that model-specific visuals are output to hard-disk.",
      "Custom Result: Return a custom Result object with methods specific to your model fitting problem.",
      "Latent Variables: Declaring a `Latent` class on the analysis to output latent variables to hard-disk.",
      "Custom Output: Add methods which output model-specific results to hard-disk in the `files` folder (e.g. as .json"
    ],
    "cross_refs": [
      "autofit/non_linear/analysis/analysis.py",
      "autofit/non_linear/fitness.py",
      "my_fit.py",
      "start_here.py"
    ],
    "notebook": "notebooks/cookbooks/analysis.ipynb",
    "path": "scripts/cookbooks/analysis.py",
    "summary": "The `Analysis` class is the interface between the data and model, whereby a `log_likelihood_function` is defined and called by the non-linear search to fit the model.",
    "title": "Cookbook: Analysis"
  },
  {
    "contents": [
      "No Config Behaviour: An example of what happens when a model component does not have a config file.",
      "Templates: A template config file for specifying default model component priors.",
      "Modules: Writing prior config files based on the Python module the model component Python class is contained in.",
      "Labels: Config files which specify the labels of model component parameters for visualization."
    ],
    "cross_refs": [
      "profiles.py"
    ],
    "notebook": "notebooks/cookbooks/configs.ipynb",
    "path": "scripts/cookbooks/configs.py",
    "summary": "Configuration files are used to control the behaviour model components in **PyAutoFit**, which perform the following tasks:",
    "title": "Cookbook: Config"
  },
  {
    "contents": [
      "Model Fit: Perform a model-fit using the example Gaussian + Analysis (which already ships a latent variable).",
      "What is a Latent Variable?: The Bayesian framing \u2014 a deterministic function of the model parameters whose",
      "Why Latent Variables?: Three motivating cases \u2014 physical interpretability, derived quantities, aggregates.",
      "How PyAutoFit Computes Latents: The `Latent.variables` hook and where in the search lifecycle it runs.",
      "Two Output Modes: Every-sample versus N-draws-from-PDF, the `output.yaml` flags that toggle between them, and",
      "Errors on Latents: The 1\u03c3 / 3\u03c3 intervals are empirical quantiles of the *induced* latent posterior \u2014 not",
      "Posterior Draws Under the Hood: What `analysis.compute_latent_samples(result.samples)` actually does.",
      "Loading Results Downstream: In-session access via the `Samples` API and out-of-session access via files /",
      "When To Add A Latent vs A Sampled Parameter: A short rule-of-thumb."
    ],
    "cross_refs": [
      "PyAutoFit/autofit/example/analysis.py",
      "PyAutoFit/autofit/non_linear/analysis/latent.py",
      "cookbooks/analysis.py",
      "cookbooks/result.py",
      "cookbooks/samples.py"
    ],
    "notebook": "notebooks/cookbooks/latent_variables.ipynb",
    "path": "scripts/cookbooks/latent_variables.py",
    "summary": "A latent variable is a quantity derived from the model parameters that is not itself sampled by the non-linear search. Once the search has explored parameter space, every accepted sample can be transformed into a value of the latent variable, building up a posterior distribution for it. This lets you report scientifically meaningful quantities (with proper Bayesian uncertainties) without paying any cost during likelihood evaluation.",
    "title": "Cookbook: Latent Variables"
  },
  {
    "contents": [
      "Models",
      "Python Class Template: The template of a model component written as a Python class.",
      "Model Composition (Model): Creating a model via `af.Model()`.",
      "Priors (Model): How the default priors of a model are set and how to customize them.",
      "Instances (Model): Creating an instance of a model via input parameters.",
      "Model Customization (Model): Customizing a model (e.g. fixing parameters or linking them to one another).",
      "Tuple Parameters (Model): Defining model components with parameters that are tuples.",
      "Json Output (Model): Output a model in human readable text via a .json file and loading it back again.",
      "Model Composition (Collection): Creating a model via `af.Collection()`.",
      "Priors (Collection): How the default priors of a collection are set and how to customize them.",
      "Instances (Collection): Create an instance of a collection via input parameters.",
      "Model Customization (Collection): Customize a collection (e.g. fixing parameters or linking them to one another).",
      "Json Output (Collection): Output a collection in human readable text via a .json file and loading it back again.",
      "Extensible Models (Collection): Using collections to extend models with new model components, including the use",
      "Model Composition (af.Array): Composing models using NumPy arrays and `af.Array`().",
      "Prior Customization (af.Array): How to customize the priors of a numpy array model.",
      "Instances (af.Array): Create an instance of a numpy array model via input parameters.",
      "Model Customization (af.Array): Customize a numpy array model (e.g. fixing parameters or linking them to one another).",
      "Json Output (af.Array): Output a numpy array model in human readable text via a .json file and loading it back again.",
      "Extensible Models (af.Array): Using numpy arrays to compose models with a flexible number of parameters.",
      "Wrap Up: A summary of model composition in PyAutoFit."
    ],
    "cross_refs": [],
    "notebook": "notebooks/cookbooks/model.ipynb",
    "path": "scripts/cookbooks/model.py",
    "summary": "Model composition is the process of defining a probabilistic model as a collection of model components, which are ultimate fitted to a dataset via a non-linear search.",
    "title": "Cookbook: Models"
  },
  {
    "contents": [
      "Prior Identity And Shared Priors: How linked parameters work via Python object identity.",
      "Prior Tuples And Ordering: The canonical ordering of priors that defines the parameter vector layout.",
      "Argument Dictionaries: Building ``{Prior: value}`` dictionaries and using ``instance_for_arguments`` directly.",
      "Model Tree Navigation: Using ``paths``, ``object_for_path``, and ``path_instance_tuples_for_class`` to traverse models.",
      "Creating New Models From Existing Ones: ``mapper_from_prior_arguments``, ``take_attributes``, ``from_instance``.",
      "Model Subsetting: ``with_paths`` and ``without_paths`` to extract sub-models.",
      "Freezing For Performance: Caching repeated lookups during fitting.",
      "Serialization Round Trip: ``dict()`` and ``from_dict()`` for JSON persistence."
    ],
    "cross_refs": [],
    "notebook": "notebooks/cookbooks/model_internal.ipynb",
    "path": "scripts/cookbooks/model_internal.py",
    "summary": "The model composition cookbooks show how to compose models and fit them to data using the high level **PyAutoFit** API (e.g. ``af.Model``, ``af.Collection``, ``af.Array``).",
    "title": "Cookbook: Model Internals"
  },
  {
    "contents": [
      "Python Class Template: The template of multi level model components written as a Python class.",
      "Model Composition: How to compose a multi-level model using the `af.Model()` object.",
      "Instances:  Creating an instance of a multi-level model via input parameters.",
      "Why Use Multi-Level Models?: A description of the benefits of using multi-level models compared to a `Collection`.",
      "Model Customization: Customizing a multi-level model (e.g. fixing parameters or linking them to one another).",
      "Alternative API: Alternative API for multi-level models which may be more concise and readable for certain models.",
      "Json Output (Model): Output a multi-level model in human readable text via a .json file and loading it back again."
    ],
    "cross_refs": [],
    "notebook": "notebooks/cookbooks/multi_level_model.ipynb",
    "path": "scripts/cookbooks/multi_level_model.py",
    "summary": "A multi level model is one where one or more of the input parameters in the model components `__init__` constructor are Python classes, as opposed to a float or tuple.",
    "title": "Cookbook: Multi Level Models"
  },
  {
    "contents": [
      "Model Fit: Setup a model-fit to 3 datasets to illustrate multi-dataset fitting.",
      "Analysis List: Create a list of `Analysis` objects, one for each dataset, which are fitted simultaneously.",
      "Analysis Factor: Wrap each `Analysis` object in an `AnalysisFactor`, which pairs it with the model and prepares it for model fitting.",
      "Factor Graph: Combine all `AnalysisFactor` objects into a `FactorGraphModel`, which represents a global model fit to multiple datasets.",
      "Result List: Use the output of fits to multiple datasets which are a list of `Result` objects.",
      "Variable Model Across Datasets: Fit a model where certain parameters vary across the datasets whereas others",
      "Relational Model: Fit models where certain parameters vary across the dataset as a user",
      "Different Analysis Objects: Fit multiple datasets where each dataset is fitted by a different `Analysis` class,",
      "Hierarchical / Graphical Models: Use hierarchical / graphical models to fit multiple datasets simultaneously,",
      "Interpolation: Fit multiple datasets with a model one-by-one and interpolation over a smoothly varying parameter",
      "Wrap Up: A summary of multi-dataset fitting in PyAutoFit."
    ],
    "cross_refs": [
      "features/interpolation.ipynb"
    ],
    "notebook": "notebooks/cookbooks/multiple_datasets.ipynb",
    "path": "scripts/cookbooks/multiple_datasets.py",
    "summary": "This cookbook illustrates how to fit multiple datasets simultaneously, where each dataset is fitted by a different `Analysis` class.",
    "title": "Cookbook: Multiple Datasets"
  },
  {
    "contents": [
      "Simple Fit: Perform a simple model-fit to generate a `Result` object.",
      "Info: Print the `info` attribute of the `Result` object to display a summary of the model-fit.",
      "Max Log Likelihood Instance: Getting the maximum likelihood model instance.",
      "Samples: Getting the samples of the non-linear search from a result.",
      "Custom Result: Extending the `Result` object with custom attributes specific to the model-fit.",
      "Output To Hard-Disk: Output results to hard-disk so they can be inspected and used to restart a crashed search.",
      "Files: The files that are stored in the `files` folder that is created when results are output to hard-disk.",
      "Loading From Hard-disk: Loading results from hard-disk to Python variables via the aggregator.",
      "Generators: Why loading results uses Python generators to ensure memory efficiency.",
      "Samples: The samples of the non-linear search loaded via the aggregator.",
      "Loading Model: The model fitted by the non-linear search.",
      "Loading Search: The search used to perform the model-fit.",
      "Loading Samples: The samples of the non-linear search (e.g. all parameter values, log likelihoods, etc.).",
      "Loading Samples Info: Additional information on the samples.",
      "Loading Samples Summary: A summary of the samples of the non-linear search (e.g. the maximum log likelihood model).",
      "Loading Info: The `info` dictionary passed to the search.",
      "Custom Output: Extend `Analysis` classes to output additional information which can be loaded via the aggregator.",
      "Querying Datasets: Query based on the name of the dataset.",
      "Querying Searches: Query based on the name of the search.",
      "Querying Models: Query based on the model that is fitted.",
      "Querying Results: Query based on the results of the model-fit.",
      "Querying with Logic: Use logic to combine queries to load specific results (e.g. AND, OR, etc.).",
      "Database: Building a database file from the output folder.",
      "Unique Identifiers: The unique identifier of each model-fit.",
      "Building From Output Folder: Build the database from the output folder on hard-disk.",
      "Writing Directly To Database: Writing results directly to the database."
    ],
    "cross_refs": [
      "//docs.py",
      "samples.py"
    ],
    "notebook": "notebooks/cookbooks/result.ipynb",
    "path": "scripts/cookbooks/result.py",
    "summary": "A non-linear search fits a model to a dataset, returning a `Result` object that contains a lot of information on the model-fit.",
    "title": "Cookbook: Result"
  },
  {
    "contents": [
      "Model Fit: Perform a simple model-fit to create a ``Samples`` object.",
      "Samples: The `Samples` object`, containing all non-linear samples (e.g. parameters, log likelihoods, etc.).",
      "Parameters: Accessing the parameters of the model from the samples.",
      "Figures of Merit: The log likelihood, log prior, log posterior and weight_list of every accepted sample.",
      "Instances: Returning instances of the model corresponding to a particular sample (e.g. the maximum log likelihood).",
      "Posterior / PDF: The median PDF model instance and PDF vectors of all model parameters via 1D marginalization.",
      "Errors: The errors on every parameter estimated from the PDF, computed via marginalized 1D PDFs at an input sigma.",
      "Samples Summary: A summary of the samples of the non-linear search (e.g. the maximum log likelihood model) which can",
      "Sample Instance: The model instance of any accepted sample.",
      "Search Plots: Plots of the non-linear search, for example a corner plot or 1D PDF of every parameter.",
      "Maximum Likelihood: The maximum log likelihood model value.",
      "Bayesian Evidence: The log evidence estimated via a nested sampling algorithm.",
      "Collection: Results created from models defined via a `Collection` object.",
      "Lists: Extracting results as Python lists instead of instances.",
      "Latex: Producing latex tables of results (e.g. for a paper).",
      "Derived Quantities: Computing quantities and errors for quantities and parameters not included directly in the model.",
      "Derived Errors Manual (Advanced): Manually computing errors on derived quantities from the PDF of samples.",
      "Samples Filtering (Advanced): Filter the `Samples` object to only contain samples fulfilling certain criteria."
    ],
    "cross_refs": [
      "/features/bayes_model_comparison.py",
      "corner.py",
      "get_dist.py"
    ],
    "notebook": "notebooks/cookbooks/samples.ipynb",
    "path": "scripts/cookbooks/samples.py",
    "summary": "A non-linear search samples parameter space to find the global maximum log likelihood solution.",
    "title": "Cookbook: Samples"
  },
  {
    "contents": [
      "Example Fit: A simple example of a non-linear search to remind us how it works.",
      "Output To Hard-Disk: Output results to hard-disk so they can be inspected and used to restart a crashed search.",
      "Output Customization: Customize the output of a non-linear search to hard-disk.",
      "Unique Identifier: Ensure results are output in unique folders, so they do not overwrite each other.",
      "Iterations Per Update: Control how often non-linear searches output results to hard-disk.",
      "Parallelization: Use parallel processing to speed up the sampling of parameter space.",
      "Plots: Perform non-linear search specific visualization using their in-built visualization tools.",
      "Start Point: Manually specify the start point of a non-linear search, or sample a specific region of parameter space.",
      "Emcee (MCMC): The Emcee ensemble sampler MCMC.",
      "Zeus (MCMC): The Zeus ensemble sampler MCMC.",
      "DynestyDynamic (Nested Sampling): The Dynesty dynamic nested sampler.",
      "DynestyStatic (Nested Sampling): The Dynesty static nested sampler.",
      "LBFGS: The L-BFGS scipy optimization."
    ],
    "cross_refs": [
      "autofit_workspace/notebooks/plot/emcee_plotter.ipynb",
      "autofit_workspace/notebooks/searches/mcmc.ipynb"
    ],
    "notebook": "notebooks/cookbooks/search.ipynb",
    "path": "scripts/cookbooks/search.py",
    "summary": "This cookbook provides an overview of the non-linear searches available in **PyAutoFit**, and how to use them.",
    "title": "Cookbook: Searches"
  },
  {
    "contents": [
      "Example Source Code (`af.ex`)",
      "Dataset",
      "Analysis",
      "Model",
      "Analysis Factors",
      "Factor Graph",
      "Search",
      "Hierarchical Models",
      "Expectation Propagation"
    ],
    "cross_refs": [],
    "notebook": "notebooks/features/graphical_models.ipynb",
    "path": "scripts/features/graphical_models.py",
    "summary": "The examples so far have focused on fitting one model to one dataset, for example fitting 1D profiles composed of Gaussians to noisy 1D data. When multiple datasets were available each is fitted individually and their results interpreted one-by-one.",
    "title": "Feature: Graphical Models"
  },
  {
    "contents": [
      "Example Source Code (`af.ex`)",
      "Dataset",
      "Fit",
      "Interpolation",
      "Serialization",
      "Database"
    ],
    "cross_refs": [
      "cookbook/database.ipynb",
      "interpolation.py"
    ],
    "notebook": "notebooks/features/interpolate.ipynb",
    "path": "scripts/features/interpolate.py",
    "summary": "It is common to fit a model to many similar datasets, where it is anticipated that one or more model parameters vary smoothly across the datasets.",
    "title": "Feature: Interpolate"
  },
  {
    "contents": [
      "Metrics",
      "Example Source Code (`af.ex`)",
      "Data",
      "Model x1 Gaussian",
      "Model x2 Gaussian",
      "Model x3 Gaussian",
      "Wrap Up"
    ],
    "cross_refs": [],
    "notebook": "notebooks/features/model_comparison.ipynb",
    "path": "scripts/features/model_comparison.py",
    "summary": "Common questions when fitting a model to data are: what model should I use? How many parameters should the model have? Is the model too complex or too simple?",
    "title": "Feature: Model Comparison"
  },
  {
    "contents": [
      "Example Source Code (`af.ex`)",
      "Data",
      "Analysis",
      "Model",
      "Search 1",
      "Result 1",
      "Search 2",
      "Model",
      "Result 2",
      "Search 3",
      "Prior Passing",
      "EXAMPLE",
      "Prerequisites",
      "Overview",
      "Model-Fit",
      "Instance & Model",
      "Component Specification",
      "Take Attributes",
      "As Model"
    ],
    "cross_refs": [],
    "notebook": "notebooks/features/search_chaining.ipynb",
    "path": "scripts/features/search_chaining.py",
    "summary": "To perform a model-fit, we typically compose one model and fit it to our data using one non-linear search.",
    "title": "Feature: Search Chaining"
  },
  {
    "contents": [
      "Example Source Code (`af.ex`)",
      "Data",
      "Model",
      "Analysis",
      "Search",
      "Result",
      "Search Grid Search"
    ],
    "cross_refs": [],
    "notebook": "notebooks/features/search_grid_search.ipynb",
    "path": "scripts/features/search_grid_search.py",
    "summary": "A classic method to perform model-fitting is a grid search, where the parameters of a model are divided on to a grid of values and the likelihood of each set of parameters on this grid is sampled. For low dimensionality problems this simple approach can be sufficient to locate high likelihood solutions, however it scales poorly to higher dimensional problems.",
    "title": "Feature: Search Grid Search"
  },
  {
    "contents": [
      "Example Source Code (`af.ex`)",
      "Data",
      "Analysis",
      "Model Comparison",
      "Sensitivity Mapping",
      "Base Model",
      "Perturb Model",
      "Mapping Grid",
      "Simulation Instance",
      "Simulate Function Class",
      "Base Fit",
      "Perturb Fit",
      "Results"
    ],
    "cross_refs": [],
    "notebook": "notebooks/features/sensitivity_mapping.ipynb",
    "path": "scripts/features/sensitivity_mapping.py",
    "summary": "Bayesian model comparison allows us to take a dataset, fit it with multiple models and use the Bayesian evidence to quantify which model objectively gives the best-fit following the principles of Occam's Razor.",
    "title": "Feature: Sensitivity Mapping"
  },
  {
    "contents": [
      "Example Source Code (`af.ex`)",
      "Dataset",
      "Analysis",
      "Shared State",
      "Model",
      "Analysis Factors / Factor Graph",
      "Search"
    ],
    "cross_refs": [
      "graphical_models.py"
    ],
    "notebook": "notebooks/features/shared_analysis_state.ipynb",
    "path": "scripts/features/shared_analysis_state.py",
    "summary": "The `graphical_models.py` feature example showed how to fit many datasets simultaneously with a `FactorGraphModel`, where each dataset has its own `Analysis` (and therefore its own `log_likelihood_function`) and the factors are linked by shared priors. When a `FactorGraphModel` evaluates its likelihood it loops over every factor, calls each factor's `log_likelihood_function`, and sums the results.",
    "title": "Feature: Shared Analysis State"
  },
  {
    "contents": [
      "Example Use Case",
      "Model",
      "Instances",
      "Analysis",
      "Non Linear Search",
      "Model Fit",
      "Result",
      "Samples",
      "Multiple Datasets",
      "Factor Graph",
      "Wrap Up",
      "Resources",
      "Extending Models"
    ],
    "cross_refs": [],
    "notebook": "notebooks/overview/overview_1_the_basics.ipynb",
    "path": "scripts/overview/overview_1_the_basics.py",
    "summary": "--------------------",
    "title": "Overview: The Basics"
  },
  {
    "contents": [
      "Data",
      "On The Fly",
      "Hard Disk Output",
      "Visualization",
      "Loading Results",
      "Result Customization",
      "Model Composition",
      "Searches",
      "Configs",
      "Database",
      "Scaling Up",
      "Wrap Up"
    ],
    "cross_refs": [],
    "notebook": "notebooks/overview/overview_2_scientific_workflow.ipynb",
    "path": "scripts/overview/overview_2_scientific_workflow.py",
    "summary": "A scientific workflow comprises the tasks you perform to conduct a scientific study. This includes fitting models to datasets, interpreting the results, and gaining insights into your scientific problem.",
    "title": "Overview: Scientific Workflow"
  },
  {
    "contents": [
      "Graphical Models",
      "Hierarchical Models",
      "Model Comparison",
      "Interpolation",
      "Search Grid Search",
      "Search Chaining",
      "Sensitivity Mapping"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/HowToFit/blob/main/notebooks/chapter_3_graphical_models/tutorial_4_hierachical_models.ipynb",
      "//github.com/PyAutoLabs/autofit_workspace/blob/main/notebooks/features/graphical_models.ipynb",
      "//github.com/PyAutoLabs/autofit_workspace/blob/main/notebooks/features/interpolate.ipynb",
      "//github.com/PyAutoLabs/autofit_workspace/blob/main/notebooks/features/model_comparison.ipynb",
      "//github.com/PyAutoLabs/autofit_workspace/blob/main/notebooks/features/search_grid_search.ipynb",
      "//github.com/PyAutoLabs/autofit_workspace/blob/main/notebooks/features/sensitivity_mapping.ipynb"
    ],
    "notebook": "notebooks/overview/overview_3_statistical_methods.ipynb",
    "path": "scripts/overview/overview_3_statistical_methods.py",
    "summary": "**PyAutoFit** supports numerous statistical methods that allow for advanced Bayesian inference to be performed.",
    "title": "Overview: Statistical Methods"
  },
  {
    "contents": [
      "Notation",
      "Plotting",
      "Search Specific Visualization",
      "Plots"
    ],
    "cross_refs": [
      "corner.py",
      "overview/simple/fit.py"
    ],
    "notebook": "notebooks/plot/dynesty_plotter.ipynb",
    "path": "scripts/plot/dynesty_plotter.py",
    "summary": "This example illustrates how to plot visualization summarizing the results of a dynesty non-linear search using the `autofit.plot` module-level functions.",
    "title": "Plots: dynesty_plotter"
  },
  {
    "contents": [
      "Notation",
      "Plotting",
      "Search Specific Visualization"
    ],
    "cross_refs": [
      "corner.py",
      "overview/simple/fit.py"
    ],
    "notebook": "notebooks/plot/emcee_plotter.ipynb",
    "path": "scripts/plot/emcee_plotter.py",
    "summary": "This example illustrates how to plot visualization summarizing the results of a emcee non-linear search using the `autofit.plot` module-level functions.",
    "title": "Plots: emcee_plotter"
  },
  {
    "contents": [
      "Model Fit",
      "Param Names",
      "GetDist MCSamples",
      "Parameter Names",
      "GetDist Plotter",
      "GetDist Subplots",
      "GetDist Single Plots",
      "Output",
      "GetDist Other Plots",
      "Plotting Multiple Samples"
    ],
    "cross_refs": [
      "overview/simple/fit.py"
    ],
    "notebook": "notebooks/plot/get_dist.ipynb",
    "path": "scripts/plot/get_dist.py",
    "summary": "This example illustrates how to plot visualization summarizing the results of model-fit using any non-linear search using GetDist:",
    "title": "Plots: GetDist"
  },
  {
    "contents": [
      "Notation",
      "Plotting",
      "Search Specific Visualization",
      "Plots"
    ],
    "cross_refs": [
      "corner.py",
      "overview/simple/fit.py"
    ],
    "notebook": "notebooks/plot/nautilus_plotter.ipynb",
    "path": "scripts/plot/nautilus_plotter.py",
    "summary": "This example illustrates how to plot visualization summarizing the results of a nautilus non-linear search using the `autofit.plot` module-level functions.",
    "title": "Plots: nautilus_plotter"
  },
  {
    "contents": [
      "Notation",
      "Plotting",
      "Search Specific Visualization"
    ],
    "cross_refs": [
      "corner.py",
      "overview/simple/fit.py"
    ],
    "notebook": "notebooks/plot/zeus_plotter.ipynb",
    "path": "scripts/plot/zeus_plotter.py",
    "summary": "This example illustrates how to plot visualization summarizing the results of a zeus non-linear search using the `autofit.plot` module-level functions.",
    "title": "Plots: zeus_plotter"
  },
  {
    "contents": [
      "Data",
      "Model + Analysis",
      "Search: Emcee",
      "Search: Zeus",
      "Search: BlackJAXNUTS",
      "Search Internal"
    ],
    "cross_refs": [],
    "notebook": "notebooks/searches/mcmc.ipynb",
    "path": "scripts/searches/mcmc.py",
    "summary": "This example illustrates how to use the MCMC sampler algorithms supported by **PyAutoFit**:",
    "title": "Searches: MCMC"
  },
  {
    "contents": [
      "Data",
      "Model + Analysis",
      "Search: Drawer",
      "Search: LBFGS",
      "Search Internal"
    ],
    "cross_refs": [
      "//github.com/PyAutoLabs/PyAutoFit/blob/main/autofit/non_linear/optimize/drawer/drawer.py"
    ],
    "notebook": "notebooks/searches/mle.ipynb",
    "path": "scripts/searches/mle.py",
    "summary": "This example illustrates how to use the maximum likelihood / optimization algorithms supported by **PyAutoFit**:",
    "title": "Searches: Maximum Likelihood Estimation"
  },
  {
    "contents": [
      "Data",
      "Model + Analysis",
      "Search: DynestyStatic",
      "Search: DynestyDynamic",
      "Search: Nautilus",
      "Search: NSS",
      "Search Internal"
    ],
    "cross_refs": [],
    "notebook": "notebooks/searches/nest.ipynb",
    "path": "scripts/searches/nest.py",
    "summary": "This example illustrates how to use the nested sampling algorithms supported by **PyAutoFit**:",
    "title": "Searches: Nested Sampling"
  },
  {
    "contents": [
      "Comparison to Priors",
      "Example Source Code (`af.ex`)",
      "Start Here Notebook",
      "Data",
      "Start Point Priors",
      "Start Point",
      "Search + Analysis + Model-Fit",
      "Result"
    ],
    "cross_refs": [
      "modeling/start_here.ipynb"
    ],
    "notebook": "notebooks/searches/start_point.ipynb",
    "path": "scripts/searches/start_point.py",
    "summary": "For maximum likelihood estimator (MLE) and Markov Chain Monte Carlo (MCMC) non-linear searches, parameter space sampling is built around having a \"location\" in parameter space.",
    "title": "Feature: Start Point"
  },
  {
    "contents": [
      "Gaussian x1",
      "Gaussian x1 (0)",
      "Gaussian x1 (1)",
      "Gaussian x1 (2)",
      "Gaussian x1 (Identical 0)",
      "Gaussian x1 (Identical 1)",
      "Gaussian x1 (Identical 2)",
      "Gaussian x1 + Exponential x1",
      "Gaussian x2 + Exponential x1",
      "Gaussian x2",
      "Gaussian x3",
      "Gaussian x5",
      "Gaussian x1 unconvolved",
      "Gaussian x1 convolved",
      "Gaussian x1 with feature",
      "Gaussian x2 split",
      "Gaussian x1 time"
    ],
    "cross_refs": [],
    "notebook": "notebooks/simulators/simulators.ipynb",
    "path": "scripts/simulators/simulators.py",
    "summary": "These scripts simulate the 1D Gaussian datasets used to demonstrate model-fitting.",
    "title": "__Simulators__"
  },
  {
    "contents": [
      "Gaussian x1 low snr (centre fixed to 50.0)",
      "Gaussian x1 low snr (centre drawn from parent Gaussian distribution to 50.0)",
      "Gaussian x2 offset centre"
    ],
    "cross_refs": [],
    "notebook": "notebooks/simulators/simulators_sample.ipynb",
    "path": "scripts/simulators/simulators_sample.py",
    "summary": "These scripts simulates many 1D Gaussian datasets with a low signal to noise ratio, which are used to demonstrate model-fitting.",
    "title": "__Simulators__"
  },
  {
    "contents": [],
    "cross_refs": [],
    "notebook": "notebooks/simulators/util.ipynb",
    "path": "scripts/simulators/util.py",
    "summary": "(no summary in script docstring)",
    "title": "util"
  }
]