如何在python中手动生成没有逆分布函数的QQ图

Question

I have 4 different distributions which I've fitted to a sample of observations. Now I want to compare my results and find the best solution. I know there are a lot of different methods to do that, but I'd like to use a quantile-quantile (qq) plot.

The formulas for my 4 distributions are:

where K ₀ is the modified Bessel function of the second kind and zeroth order, and Γ is the gamma function.

My sample style looks roughly like this: (0.2, 0.2, 0.2, 0.3, 0.3, 0.4, 0.4, 0.4, 0.4, 0.6, 0.7 ...), so I have multiple identical values and also gaps in between them.

I've read the instructions on this site and tried to implement them in python. So, like in the link:

1) I sorted my data from the smallest to the largest value.

2) I computed "n" evenly spaced points on the interval (0,1), where "n" is my sample size.

3) And this is the point I can't manage.

As far as I understand, I should now use the values I calculated beforehand (those evenly spaced values), put them in the inverse functions of my above distributions and thus compute the theoretical quantiles of my distributions.

For reference, here are the inverse functions (partly calculated with wolframalpha , and as far it was possible):

where W is the Lambert W-function and everything in brackets afterwards is the argument.

The problem is, apparently there doesn't exist an inverse function for the first distribution. The next one would probably produce complex values (negative under the root, because b = 0.55 according to the fit) and the last two of them have a Lambert W-Function (where I'm unsecure how to implement them in python).

So my question is, is there a way to calculate the qq plots without the analytical expressions of the inverse distribution functions?

I'd appreciate any help you could give me very much!

Answer 1

A simpler and more conventional way to go about this is to compute the log likelihood for each model and choose that one that has the greatest log likelihood. You don't need the cdf or quantile function for that, only the density function, which you have already.

The log likelihood is just the sum of log p(x|model) where p(x|model) is the probability density of datum x under a given model. Here "model" = model with parameters selected by maximizing the log likelihood over the possible values of the parameters.

You can be more careful about this by integrating the log likelihood over the parameter space, taking into account also any prior probability assigned to each model; that would be a Bayesian approach.

It sounds like you are essentially looking to choose a model by minimizing the Kolmogorov-Smirnov (KS) statistic, which despite it's heavy name, is pretty simple -- it is the difference between the would-be quantile function and the empirical quantile. That's defensible, but I think comparing log likelihoods is more conventional, and also simpler since you need only the pdf.

Answer 2

It happens that there is an easier way. It's taken me a day or two to dig around until I was pointed toward the right method in scipy.stats. I was looking for the wrong sort of name!

First, build a subclass of rv_continuous to represent one of your distributions. We know the pdf for your distributions, so that's what we define. In this case there's just one parameter. If more are needed just add them to the def statement and use them in the return statement as required.

>>> from scipy import stats
>>> param = 3/2
>>> from math import exp
>>> class NoName(stats.rv_continuous):
...     def _pdf(self, x, param):
...         return param*exp(-param*x)
...     

Now create an instance of this object, declare the lower end of its support (ie, the lowest value that the rv can assume), and what the parameters are called.

>>> noname = NoName(a=0, shapes='param')

I don't have an actual sample of values to play with. I'll create a pseudo-random sample.

>>> sample = noname.rvs(size=100, param=param)

Sort it to make it into the so-called 'empirical cdf'.

>>> empirical_cdf = sorted(sample)

The sample has 100 elements, therefore generate 100 points at which to sample the inverse cdf, or quantile function, as discussed in the paper your referenced.

>>> theoretical_points = [(_-0.5)/len(sample) for _ in range(1, 1+len(sample))]

Get the quantile function values at these points.

>>> theoretical_cdf = [noname.ppf(_, param=param) for _ in theoretical_points]

Plot it all.

>>> from matplotlib import pyplot as plt
>>> plt.plot([0,3.5], [0, 3.5], 'b-')
[<matplotlib.lines.Line2D object at 0x000000000921B400>]
>>> plt.scatter(empirical_cdf, theoretical_cdf)
<matplotlib.collections.PathCollection object at 0x000000000921BD30>
>>> plt.show()

Here's the QQ plot that results.

Answer 3

Darn it ... Sorry, I was fixated on a slick solution to somehow bypass the missing inverse CDF and calculate the quantiles directly (and avoid any numerically approaches). But it can also be done by simple brute force.

At first you have to define the quantiles for your distributions yourself (for instance ten times more accurate than the original/empirical quantiles). Then you need to calculate the corresponding CDF values. Then you have to compare these values one by one with the ones which were calculated in step 2 in the question. The according quantiles of the CDF values with the smallest deviations are the ones you were looking for.

The precision of this solution is limited by the resolution of the quantiles you defined yourself.

But maybe I'm wrong and there is a more elegant way to solve this problem, then I would be happy to hear it!