Draw samples from an exponential distribution.
Its probability density function is
\[f[x; \frac{1}{\beta}] = \frac{1}{\beta} \exp[-\frac{x}{\beta}],\]
for x > 0 and 0 elsewhere.
\[\beta\] is the scale parameter, which is the inverse of the rate parameter \[\lambda = 1/\beta\]. The rate parameter is an alternative, widely used parameterization of the exponential distribution [3].
The exponential distribution is a continuous analogue of the geometric distribution. It describes many common situations, such as the size of raindrops measured over many rainstorms [1], or the time between page requests to Wikipedia [2].
Note
New code should use the exponential method of a default_rng[] instance instead; please
see the Quick Start.
The scale parameter, \[\beta = 1/\lambda\]. Must be non-negative.
sizeint or tuple of ints, optionalOutput shape. If the given shape is, e.g., [m, n, k], then m * n * k
samples are drawn. If size is None [default], a single value is returned if scale is a scalar. Otherwise, np.array[scale].size samples are drawn.
Drawn samples from the parameterized exponential distribution.
References
1Peyton Z. Peebles Jr., “Probability, Random Variables and Random Signal Principles”, 4th ed, 2001, p. 57.
2Wikipedia, “Poisson process”, //en.wikipedia.org/wiki/Poisson_process
3Wikipedia, “Exponential distribution”, //en.wikipedia.org/wiki/Exponential_distribution
I think you are actually asking about a regression problem, which is what Praveen was suggesting.
You have a bog standard exponential decay that arrives at the y-axis at about y=0.27. Its equation is therefore y = 0.27*exp[-0.27*x]. I can model gaussian error around the values of this function and plot the result using the following code.
import matplotlib.pyplot as plt
from math import exp
from scipy.stats import norm
x = range[0, 16]
Y = [0.27*exp[-0.27*_] for _ in x]
error = norm.rvs[0, scale=0.05, size=9]
simulated_data = [max[0, y+e] for [y,e] in zip[Y[:9],error]]
plt.plot[x, Y, 'b-']
plt.plot[x[:9], simulated_data, 'r.']
plt.show[]
print [x[:9]]
print [simulated_data]
Here's the plot. Notice that I save the output values for subsequent use.
Now I can calculate the nonlinear regression of the exponential decay values, contaminated with noise, on the independent variable, which is what curve_fit does.
from math import exp
from scipy.optimize import curve_fit
import numpy as np
def model[x, p]:
return p*np.exp[-p*x]
x = list[range[9]]
Y = [0.22219001972988275, 0.15537454187341937, 0.15864069451825827, 0.056411162886672819, 0.037398831058143338, 0.10278251869912845, 0.03984605649260467, 0.0035360087611421981, 0.075855255999424692]
popt, pcov = curve_fit[model, x, Y]
print [popt[0]]
print [pcov]
The bonus is that, not only does curve_fit calculate an estimate for the parameter — 0.207962159793 — it also offers an estimate for this estimate's variance
— 0.00086071 — as an element of pcov. This would appear to be a fairly small value, given the small sample size.
Here's how to calculate the residuals. Notice that each residual is the difference between the data value and the value estimated from x using the parameter estimate.
residuals = [y-model[_, popt[0]] for [y, _] in zip[Y, x]]
print [residuals]
If you wanted to further 'test that my function is indeed going through the data points' then I would suggest looking for patterns in the residuals. But discussions like this might be beyond
what's welcomed on stackoverflow: Q-Q and P-P plots, plots of residuals vs y or x, and so on.
View Discussion
Improve Article
Save Article
View Discussion
Improve Article
Save Article
With the help of numpy.random.exponential[] method, we can get the random samples from exponential distribution and returns the numpy array of random samples by using this method.
exponential distribution
Syntax : numpy.random.exponential[scale=1.0, size=None]
Return : Return the random samples of numpy array.
Example #1 :
In this example we can see that by using numpy.random.exponential[] method, we are able to get the random samples of exponential distribution and return the samples of numpy array.
Python3
import numpy as np
import matplotlib.pyplot as plt
gfg = np.random.exponential[3.45, 10000]
count, bins, ignored = plt.hist[gfg, 14, density = True]
plt.show[]
Output :
Example #2 :
Python3
import numpy as np
import matplotlib.pyplot as plt
gfg = np.random.exponential[101.123, 10000]
gfg1 = np.random.exponential[gfg, 10000]
count, bins, ignored = plt.hist[gfg1, 14, density = True]
plt.show[]
Output :