Update README.md with likelihood info

Author: stefanradev93

README.md

@@ -77,13 +77,13 @@ Next, we create our BayesFlow setup consisting of a summary and an inference net
 ```python
 summary_net = bf.networks.DeepSet()
 inference_net = bf.networks.InvertibleNetwork(num_params=2)
-amortizer = bf.amortizers.AmortizedPosterior(inference_net, summary_net)
+amortized_posterior = bf.amortizers.AmortizedPosterior(inference_net, summary_net)
 ```
 
 Finally, we connect the networks with the generative model via a `Trainer` instance:
 
 ```python
-trainer = bf.trainers.Trainer(amortizer=amortizer, generative_model=generative_model)
+trainer = bf.trainers.Trainer(amortizer=amortized_posterior, generative_model=generative_model)
 ```
 
 We are now ready to train an amortized posterior approximator. For instance,
@@ -113,7 +113,7 @@ per data set:
 
 ```python
 new_sims = trainer.configurator(generative_model(200))
-posterior_draws = amortizer.sample(new_sims, n_samples=500)
+posterior_draws = amortized_posterior.sample(new_sims, n_samples=500)
 ```
 
 We can then quickly inspect the how well the model can recover its parameters
@@ -167,7 +167,7 @@ In order to use this method, you should only provide the `summary_loss_fun` argu
 to the `AmortizedPosterior` instance:
 
 ```python
-amortizer = bf.amortizers.AmortizedPosterior(inference_net, summary_net, summary_loss_fun='MMD')
+amortized_posterior = bf.amortizers.AmortizedPosterior(inference_net, summary_net, summary_loss_fun='MMD')
 ```
 
 The amortizer knows how to combine its losses and you can inspect the summary space for outliers during inference.
@@ -207,13 +207,13 @@ Next, we construct our neural network with a `PMPNetwork` for approximating post
 ```python
 summary_net = bf.networks.DeepSet()
 probability_net = bf.networks.PMPNetwork(num_models=2)
-amortizer = bf.amortizers.AmortizedModelComparison(probability_net, summary_net)
+amortized_bmc = bf.amortizers.AmortizedModelComparison(probability_net, summary_net)
 ```
 
 We combine all previous steps with a `Trainer` instance and train the neural approximator:
 
 ```python
-trainer = bf.trainers.Trainer(amortizer=amortizer, generative_model=meta_model)
+trainer = bf.trainers.Trainer(amortizer=amortized_bmc, generative_model=meta_model)
 losses = trainer.train_online(epochs=3, iterations_per_epoch=100, batch_size=32)
 ```
 
@@ -226,7 +226,7 @@ sims = trainer.configurator(meta_model(5000))
 When feeding the data to our trained network, we almost immediately obtain posterior model probabilities for each of the 5000 data sets:
 
 ```python
-model_probs = amortizer.posterior_probs(sims)
+model_probs = amortized_bmc.posterior_probs(sims)
 ```
 
 How good are these predicted probabilities in the closed world? We can have a look at the calibration:
@@ -257,13 +257,35 @@ C. (2021). Amortized Bayesian Model Comparison with Evidental Deep Learning.
 doi:10.1109/TNNLS.2021.3124052 available for free at: https://arxiv.org/abs/2004.10629
 
 - Schmitt, M., Radev, S. T., & Bürkner, P. C. (2022). Meta-Uncertainty in
-Bayesian Model Comparison. <em>ArXiv preprint</em>, available for free at:
-https://arxiv.org/abs/2210.07278
+Bayesian Model Comparison. In <em>International Conference on Artificial Intelligence
+and Statistics</em>, 11-29, PMLR, available for free at: https://arxiv.org/abs/2210.07278
 
 - Elsemüller, L., Schnuerch, M., Bürkner, P. C., & Radev, S. T. (2023). A Deep
 Learning Method for Comparing Bayesian Hierarchical Models. <em>ArXiv preprint</em>,
 available for free at: https://arxiv.org/abs/2301.11873
 
 ## Likelihood emulation
 
-Example coming soon...
+In order to learn the exchangeable (i.e., permutation invariant) likelihood from the minimal example instead of the posterior, you may use the `AmortizedLikelihood` wrapper:
+
+```python
+likelihood_net = bf.networks.InvertibleNetwork(num_params=2)
+amortized_likelihood = bf.amortizers.AmortizedLikelihood(likelihood_net)
+```
+
+This wrapper can interact with a `Trainer` instance in the same way as the `AmortizedPosterior`. Finally, you can also learn the likelihood and the posterior *simultaneously* by using the `AmortizedPosteriorLikelihood` wrapper and choosing your preferred training scheme:
+
+```python
+joint_amortizer = bf.amortizers.AmortizedPosteriorLikelihood(amortized_posterior, amortized_likelihood)
+```
+
+Learning both densities enables us to approximate marginal likelihoods or perform approximate leave-one-out cross-validation (LOO-CV) for prior or posterior predictive model comparison, respectively.
+
+### References and Further Reading
+
+Radev, S. T., Schmitt, M., Pratz, V., Picchini, U., Köthe, U., & Bürkner, P. C. (2023). 
+JANA: Jointly Amortized Neural Approximation of Complex Bayesian Models. <em>arXiv preprint</em>,
+available for free at: https://arxiv.org/abs/2302.09125
+
+## Support
+This work is supported by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany’s Excellence Strategy -– EXC-2181 - 390900948 (the Heidelberg Cluster of Excellence STRUCTURES) and -- EXC-2075 - 390740016 (the Stuttgart Cluster of Excellence SimTech), the Informatics for Life initiative funded by the Klaus Tschira Foundation, and Google Cloud through the Academic Research Grants program.