.. _5-minutes-to-zfit: ================= 5 minutes to zfit ================= The zfit library provides a simple model fitting and sampling framework for a broad list of applications. This section is designed to give an overview of the main concepts and features in the context of likelihood fits in a *crash course* manner. The simplest example is to generate, fit and plot a Gaussian distribution. The first step is to import zfit and to verify that the installation has been done successfully: .. jupyter-execute:: :hide-output: :hide-code: import os os.environ["ZFIT_DISABLE_TF_WARNINGS"] = "1" import numpy as np .. jupyter-execute:: import tensorflow as tf import zfit from zfit import z # math backend of zfit .. thebe-button:: Run this interactively Since we want to generate/fit a Gaussian within a given range, the domain of the PDF is defined by an *observable space*. This can be created using the :py:class:~zfit.Space class .. jupyter-execute:: obs = zfit.Space('x', limits=(-10, 10)) The best interpretation of the observable at this stage is that it defines the name and range of the observable axis. Using this domain, we can now create a simple Gaussian PDF. The most common PDFs are already pre-defined within the :py:mod:~zfit.pdf module, including a simple Gaussian. First, we have to define the parameters of the PDF and their limits using the :py:class:~zfit.Parameter class: .. jupyter-execute:: mu = zfit.Parameter("mu", 2.4, -1, 5) sigma = zfit.Parameter("sigma", 1.3, 0, 5) With these parameters we can instantiate the Gaussian PDF from the library .. jupyter-execute:: gauss = zfit.pdf.Gauss(obs=obs, mu=mu, sigma=sigma) It is recommended to pass the arguments of the PDF as keyword arguments. The next stage is to create a dataset to be fitted. There are several ways of producing this within the zfit framework (see the :ref:Data  section). In this case, for simplicity we simply produce it using numpy and the :func:Data.from_numpy  method: .. jupyter-execute:: data_np = np.random.normal(0, 1, size=10000) data = zfit.Data.from_numpy(obs=obs, array=data_np) Now we have all the ingredients in order to perform a maximum likelihood fit. Conceptually this corresponds to three basic steps: 1. create a loss function, in our case a negative log-likelihood :math:\log\mathcal{L}; 2. instantiate our choice of minimiser; 3. and minimise the log-likelihood. .. jupyter-execute:: # Stage 1: create an unbinned likelihood with the given PDF and dataset nll = zfit.loss.UnbinnedNLL(model=gauss, data=data) # Stage 2: instantiate a minimiser (in this case a basic minuit minimizer) minimizer = zfit.minimize.Minuit() # Stage 3: minimise the given negative likelihood result = minimizer.minimize(nll) This corresponds to the most basic example where the negative likelihood is defined within the pre-determined observable range and all the parameters in the PDF are floated in the fit. It is often the case that we want to only vary a given set of parameters. In this case it is necessary to specify which are the parameters to be floated (so all the remaining ones are fixed to their initial values). Also note that we can now do various things with the pdf such as plotting the fitting result with the model gaussian without extracting the loss minimizing parameters from result. This is possible because parameters are mutable. This means that the minimizer can directly manipulate the value of the floating parameter. So when you call the minimizer.minimize() method the value of mu changes during the optimisation. gauss.pdf() then uses this new value to calculate the pdf. .. jupyter-execute:: # Stage 3: minimise the given negative likelihood but floating only specific parameters (e.g. mu) result2 = minimizer.minimize(nll, params=[mu]) It is important to highlight that conceptually zfit separates the minimisation of the loss function with respect to the error calculation, in order to give the freedom of calculating this error whenever needed and to allow the use of external error calculation packages. In order to get an estimate for the errors, it is possible to call Hesse that will calculate the parameter uncertainties. This uses the inverse Hessian to approximate the minimum of the loss and returns a symmetric estimate. When using weighted datasets, this will automatically perform the asymptotic correction to the fit covariance matrix, returning corrected parameter uncertainties to the user. The correction applied is based on Equation 18 in this paper _. To call Hesse, do: .. jupyter-execute:: param_hesse = result.hesse() print(param_hesse) which will return a dictionary of the fit parameters as keys with error values for each one. The errors will also be added to the result object and show up when printing the result. While the hessian approximation has many advantages, it may not hold well for certain loss functions, especially for asymetric uncertainties. It is also possible to use a more CPU-intensive error calculating with the errors method. This has the advantage of taking into account all the correlations and can describe well a a loss minimum that is not well approximated by a quadratic function *(it is however not valid in the case of weights and takes considerably longer).* It estimates the lower and upper uncertainty independently. As an example, with the :py:class:~zfit.minimize.Minuit one can calculate the MINOS uncertainties with: .. jupyter-execute:: :hide-output: param_errors, _ = result.errors() .. jupyter-execute:: print(param_errors) Once we've performed the fit and obtained the corresponding uncertainties, it is now important to examine the fit results. The object result (:py:class:~zfit.minimizers.fitresult.FitResult) has all the relevant information we need: .. jupyter-execute:: print(f"Function minimum: {result.fmin}") print(f"Converged: {result.converged}") print(f"Valid: {result.valid}") This is all available if we print the fitresult (not shown here as display problems). .. jupyter-execute:: :hide-output: print(result) Similarly one can obtain only the information on the fitted parameters with .. jupyter-execute:: # Information on all the parameters in the fit print(result.params) # Printing information on specific parameters, e.g. mu print("mu={}".format(result.params[mu]['value'])) As already mentioned, there is no dedicated plotting feature within zfit. However, we can easily use external libraries, such as matplotlib and mplhep, a library for HEP-like plots _ , to do the job: .. jupyter-execute:: import mplhep import matplotlib.pyplot as plt import numpy as np lower, upper = obs.limits data_np = zfit.run(data.value()[:, 0]) # plot the data as a histogramm bins = 80 counts, bin_edges = np.histogram(data_np, bins, range=(lower[-1][0], upper[0][0])) mplhep.histplot((counts, bin_edges), yerr=True, color='black', histtype='errorbar') # evaluate the func at multiple x and plot x_plot = np.linspace(lower[-1][0], upper[0][0], num=1000) y_plot = zfit.run(gauss.pdf(x_plot, norm_range=obs)) plt.plot(x_plot, y_plot * data_np.shape[0] / bins * obs.area(), color='xkcd:blue') plt.show() The specific call to :func:zfit.run simply converts the Eager Tensor (that is already array-like) to a Numpy array. Often, this conversion is however not necessary and a Tensor can directly be used. The full script :jupyter-download:script:can be downloaded here <5 minutes to zfit>.