def calculate_linspace(distribution): if distribution[0] == 'EXP': lambda_ = distribution[1] scale_ = 1 / lambda_ return np.linspace(expon.ppf(0.001, scale=scale_), expon.ppf(0.999, scale=scale_), 1000) if distribution[0] == 'WEIBULL': scale = distribution[1] shape = distribution[2] return np.linspace(weibull_min.ppf(0.001, shape, loc=0, scale=scale), weibull_min.ppf(0.999, shape, loc=0, scale=scale), 1000) if distribution[0] == 'NORMAL': mu = distribution[1] sigma = distribution[2] return np.linspace(norm.ppf(0.001, loc=mu, scale=sigma), norm.ppf(0.999, loc=mu, scale=sigma), 1000) if distribution[0] == 'LOGNORM': mu = distribution[1] sigma = distribution[2] scale = math.exp(mu) return np.linspace(lognorm.ppf(0.001, sigma, loc=0, scale=scale), lognorm.ppf(0.999, sigma, loc=0, scale=scale), 1000) else: return np.linspace(0, 100, 1000)
def _update_canvas(self): """ Update the figure when the user changes an input value. :return: """ # Get the parameters from the form loc = float(self.loc.text()) scale = float(self.scale.text()) shape_factor = float(self.shape_factor.text()) # Get the selected distribution from the form distribution_type = self.distribution_type.currentText() if distribution_type == 'Gaussian': x = linspace(norm.ppf(0.001, loc, scale), norm.ppf(0.999, loc, scale), 200) y = norm.pdf(x, loc, scale) elif distribution_type == 'Weibull': x = linspace(weibull_min.ppf(0.001, shape_factor), weibull_min.ppf(0.999, shape_factor), 200) y = weibull_min.pdf(x, shape_factor, loc, scale) elif distribution_type == 'Rayleigh': x = linspace(rayleigh.ppf(0.001, loc, scale), rayleigh.ppf(0.999, loc, scale), 200) y = rayleigh.pdf(x, loc, scale) elif distribution_type == 'Rice': x = linspace(rice.ppf(0.001, shape_factor), rice.ppf(0.999, shape_factor), 200) y = rice.pdf(x, shape_factor, loc, scale) elif distribution_type == 'Chi Squared': x = linspace(chi2.ppf(0.001, shape_factor), chi2.ppf(0.999, shape_factor), 200) y = chi2.pdf(x, shape_factor, loc, scale) # Clear the axes for the updated plot self.axes1.clear() # Display the results self.axes1.plot(x, y, '') # Set the plot title and labels self.axes1.set_title('Probability Density Function', size=14) self.axes1.set_xlabel('x', size=12) self.axes1.set_ylabel('Probability p(x)', size=12) # Set the tick label size self.axes1.tick_params(labelsize=12) # Turn on the grid self.axes1.grid(linestyle=':', linewidth=0.5) # Update the canvas self.my_canvas.draw()
def distrib_quantile(q, largeur): """modèles de distribution pour partager en quantile (pour affichage du seuil [axvline])""" global ladistribution if ladistribution == "alpha": return alpha.ppf(q, 0.8, 0, largeur) elif ladistribution == "gauss": return stat.norm.ppf(q, 0, largeur) elif ladistribution == "triangle": return triang.ppf(q, 0, 0, largeur) elif ladistribution == "weibull": return weibull_min.ppf(q, 1.1, 0, largeur)
def inv(self, p): """ @brief Return the inverse cummulative probability for p. @param p is the value between 0 and 1 """ if p <= 0.0: p = 0.0000000000001 if p >= 1.0: p = 0.9999999999999 return weibull_min.ppf(p, self.shape, loc=self.loc, scale=self.scale)
def _get_csf(self): # composite stress at Pf probability for CS to be of final range # scale parameter for composite stress scale_sigma_c = self.scale_sigma_m / self.E_m * self.E_c sigma = weibull_min.ppf(self.Pf, self.m, scale=scale_sigma_c) # point of reaching final crack spacing epsilon_csf = hstack( (0, self._get_epsilon_c(sigma), self._get_epsilon_c(sigma))) sigma_csf = hstack((sigma, sigma, 0)) return epsilon_csf, sigma_csf
def inv(self, p): ''' @brief Return the inverse cummulative probability for p. @param p is the value between 0 and 1 ''' if p <= 0.0: p = 0.0000000000001 if p >= 1.0: p = 0.9999999999999 return weibull_min.ppf(p, self.shape, loc=self.loc, scale=self.scale)
def _get_csf(self): # composite stress at Pf probability for CS to be of final range # scale parameter for composite stress scale_sigma_c = self.scale_sigma_m / self.E_m * self.E_c sigma = weibull_min.ppf(self.Pf, self.m, scale = scale_sigma_c) # point of reaching final crack spacing epsilon_csf = np.hstack((0, self._get_epsilon_c(sigma), self._get_epsilon_c(sigma ))) sigma_csf = np.hstack((sigma, sigma, 0)) return epsilon_csf, sigma_csf
def Amount(Rn, Dist, Coef): if Dist == "exp": GenP = expon.ppf(Rn, Coef[0], Coef[1]) elif Dist == "gamma": GenP = gamma.ppf(Rn, Coef[0], Coef[1], Coef[2]) elif Dist == "weibull": GenP = weibull_min.ppf(Rn, Coef[0], Coef[1], Coef[2]) elif Dist == "lognorm": GenP = np.exp(norm.ppf(Rn, Coef[0], Coef[1])) # use norm generate lognorm #elif Dist == "pearson3": # GenP = pearson3.ppf(Rn,coef[0],coef[1],coef[2]) return GenP
def _get_sigma_cu(self): '''Ultimate composite strength. The strength is given by the fiber strength related to the composite cross section by the reinforcement ratio rho and projected by the cosine of the fiber inclination into the loading direction. ''' # 0.05 quantile strength of the matrix as a criterion for matrix failure # when this value is higher than the composite strength governed by the # reinforcement stress quantile = weibull_min.ppf( 0.05, self.m, scale = self.scale_sigma_m ) # composite failure due to matrix failure if self.sigma_fu * self.V_f * cos( self.orientation ) < quantile / self.V_m: return quantile / self.V_m else: # composite failure due to fiber failure return self.sigma_fu * self.V_f * cos( self.orientation )
def _get_sigma_cu(self): '''Ultimate composite strength. The strength is given by the fiber strength related to the composite cross section by the reinforcement ratio rho and projected by the cosine of the fiber inclination into the loading direction. ''' # 0.05 quantile strength of the matrix as a criterion for matrix failure # when this value is higher than the composite strength governed by the # reinforcement stress quantile = weibull_min.ppf(0.05, self.m, scale=self.scale_sigma_m) # composite failure due to matrix failure if self.sigma_fu * self.V_f * cos( self.orientation) < quantile / self.V_m: return quantile / self.V_m else: # composite failure due to fiber failure return self.sigma_fu * self.V_f * cos(self.orientation)
zorder=11, linewidth=5) plt.scatter(x_max, y_max, c='firebrick', marker='*', label='data (max)', s=45) plt.legend(fontsize=14) plt.xlim(0, 10) plt.xlabel("x") plt.ylabel("y") plt.title(r"Data and model comparison between min and max of min(${\chi}^{2}$)") fig3.show() # error_pdf_comparison.png plot sns.distplot(np.random.normal(mu, sigma, 100000), label='gaussian') sns.distplot(np.random.logistic(loc, scale, 100000), label='logistic') plt.legend(loc='best') plt.show() # Weibull pdf plot for different parameter values from scipy.stats import weibull_min fig, ax = plt.subplots(1, 1) c_arr = np.linspace(1,3,20) mean, var, skew, kurt = weibull_min.stats(c, moments='mvsk') x = np.linspace(weibull_min.ppf(0.01, c), weibull_min.ppf(0.99, c), 100) ax.set_prop_cycle(color=[ '#1f77b4', '#aec7e8', '#ff7f0e', '#ffbb78', '#2ca02c', '#98df8a', '#d62728', '#ff9896', '#9467bd', '#c5b0d5', '#8c564b', '#c49c94', '#e377c2', '#f7b6d2', '#7f7f7f', '#c7c7c7', '#bcbd22', '#dbdb8d', '#17becf', '#9edae5']) for idx in range(len(c_arr)): ax.plot(x, weibull_min.pdf(x, c_arr[idx]), lw=5, alpha=0.6, label='c={0}'.format(np.round(c_arr[idx], 2))) plt.legend(loc='best', prop={'size': 10}) plt.title('Weibull pdf') plt.show()
from scipy.stats import weibull_min import matplotlib.pyplot as plt fig, ax = plt.subplots(1, 1) # Calculate a few first moments: c = 1.79 mean, var, skew, kurt = weibull_min.stats(c, moments='mvsk') # Display the probability density function (``pdf``): x = np.linspace(weibull_min.ppf(0.01, c), weibull_min.ppf(0.99, c), 100) ax.plot(x, weibull_min.pdf(x, c), 'r-', lw=5, alpha=0.6, label='weibull_min pdf') # Alternatively, the distribution object can be called (as a function) # to fix the shape, location and scale parameters. This returns a "frozen" # RV object holding the given parameters fixed. # Freeze the distribution and display the frozen ``pdf``: rv = weibull_min(c) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = weibull_min.ppf([0.001, 0.5, 0.999], c)
for j in range(len(x_bins)): mask1 = h_ind_bin == j + ind_min_bin real_bins[j] = hs_i[mask1].mean() weib_par_cond[j,:] = weibull_min.fit(v_i[mask1], floc=0) try: k = curve_fit(power3, real_bins, weib_par_cond[:,0], bounds=bounds)[0] a = curve_fit(power3, real_bins, weib_par_cond[:,2], bounds=bounds)[0] except RuntimeError: try: k = curve_fit(power3, real_bins[0:-1], weib_par_cond[0:-1,0], bounds=bounds)[0] a = curve_fit(power3, real_bins[0:-1], weib_par_cond[0:-1,2], bounds=bounds)[0] except RuntimeError: k = curve_fit(power3, real_bins[0:-2], weib_par_cond[0:-2,0], bounds=bounds)[0] a = curve_fit(power3, real_bins[0:-2], weib_par_cond[0:-2,2], bounds=bounds)[0] x1_50 = weibull_min.ppf( norm.cdf(u1_50), *weib_par2) # The weibull conditional distribution k_x1_50 = power3(x1_50, *k) a_x1_50 = power3(x1_50, *a) x0_50 = weibull_min.ppf( norm.cdf(u0_50), k_x1_50, loc=0, scale=a_x1_50) # import seaborn as sns # h = sns.jointplot(x= v_i , y=hs_i, s=5) # h.x, h.y = x0_50, x1_50 # h.plot_joint(plt.plot, color='C1') # ids_contour_i = [] # Compute 50-yr IFORM contour. # iform_contour_i = IFormContour(my_fit.mul_var_dist, return_period, 1,
def var(self, alph): return weibull_min.ppf(alph, self.shape, 0, self.scale)
def plot_pdf_with_raw_data(dim_index, parent_index, low_index, shape, loc, scale, distribution_type, dist_points, interval, var_name, symbol_parent_var, directory, probabilistic_model): """ Creates and saves an image, which shows a fit of a distribution. Parameters ---------- dim_index : int, The index of the current dimension (distribution). The index is used to recognise the image later. parent_index : int, The index of the variable on which the conditional is based (when no condition: None). low_index : int, The index of the interval. (needed to recognize the images later) shape : float, The value of the shape parameter. loc : float, The value of the loc parameter. (location) scale : float, The value of the scale parameter. distribution_type: str, Name of the distribution, must be "Normal", "Weibull" or "Lognormal" dist_points: list of float, The dates for the histogram. interval : list of float, The list contains the interval of the plotted distribution. var_name : str, The name of a single variable of the probabilistic model. symbol_parent_var : str, Symbol of the variable on which the conditional variable is based. directory : str, The directory where the figure should be saved probabilistic_model : ProbabilisticModel, Probabilistic model which has the particular pdf. """ fig = plt.figure() ax = fig.add_subplot(111) if distribution_type == 'Normal': x = np.linspace(norm.ppf(0.0001, loc, scale), norm.ppf(0.9999, loc, scale), 100) y = norm.pdf(x, loc, scale) text = distribution_type + ',' + \ ' μ=' + str(format(loc, '.3f')) + \ ' σ=' + str(format(scale, '.3f')) elif distribution_type == 'Weibull': x = np.linspace(weibull_min.ppf(0.0001, shape, loc, scale), weibull_min.ppf(0.9999, shape, loc, scale), 100) y = weibull_min.pdf(x, shape, loc, scale) text = distribution_type + ',' + \ ' α=' + str(format(scale, '.3f')) + \ ' β=' + str(format(shape, '.3f')) + \ ' γ=' + str(format(loc, '.3f')) elif distribution_type == 'Lognormal': x = np.linspace(lognorm.ppf(0.0001, shape, scale=scale), lognorm.ppf(0.9999, shape, scale=scale), 100) y = lognorm.pdf(x, shape, scale=scale) # plot_pdf_with_raw_data works with the scale parameter, but the user # should be presented the mu value. Consequently, the scale value must # be converted. text = distribution_type + ',' + \ ' μ=' + str(format(np.log(scale), '.3f')) + \ ' σ=' + str(format(shape, '.3f')) else: raise KeyError('No function match - {}'.format(distribution_type)) text = text + ' (' if symbol_parent_var: text = text + str(format(interval[0], '.3f')) + '≤' + \ symbol_parent_var + '<' + str(format(interval[1], '.3f')) + ', ' text = text + 'n=' + str(len(dist_points)) + ')' ax.plot(x, y, 'r-', lw=5, alpha=0.6, label=distribution_type) n_intervals_histogram = int(round(len(dist_points) / 50.0)) if n_intervals_histogram > 100: n_intervals_histogram = 100 if n_intervals_histogram < 10: n_intervals_histogram = 10 ax.hist(dist_points, n_intervals_histogram, normed=True, histtype='stepfilled', alpha=0.9, color='#54889c') ax.grid(True) plt.title(text) plt.xlabel(var_name) plt.ylabel('probability density [-]') dim_index_2_digits = str(dim_index).zfill(2) parent_index_2_digits = str(parent_index).zfill(2) low_index_2_digits = str(low_index).zfill(2) # The convention for image name is like this: 'fit_01_00_02.png' means # a plot of the second variable (01) which is conditional on the first # variable (00) and this is the third (02) fit # For the following block thanks to: https://stackoverflow.com/questions/ # 20580179/saving-a-matplotlib-graph-as-an-image-field-in-database f = BytesIO() plt.savefig(f, bbox_inches='tight') plt.close(fig) content_file = ContentFile(f.getvalue()) dists_models = DistributionModel.objects.filter( probabilistic_model=probabilistic_model) plotted_figure = PlottedFigure(probabilistic_model=probabilistic_model, distribution_model=dists_models[dim_index]) file_name = 'fit_' + dim_index_2_digits + '_' + parent_index_2_digits + \ '_' + low_index_2_digits + '.png' plotted_figure.image.save(file_name, content_file) plotted_figure.save()
def ppf_fn5(q): return weibull_min.ppf(q, c=5)
def _get_xi(self): # Nf random numbers from the interval (0,1) rn = random.rand(self.Nf) xi_rand = weibull_min.ppf(rn, self.xi_shape, scale = self.xi_scale) return xi_rand
def plot_weibull(name, metric, distribution, times, theoretical_distribution=None): scale = distribution[1] shape = distribution[2] theoretical_scale = None theoretical_shape = None # Checks whether there is a theoretical distribution to compare it to if theoretical_distribution is not None: theoretical_scale = theoretical_distribution[1] theoretical_shape = theoretical_distribution[2] fig, subplots = setup_fig_subplots(metric) fig.suptitle(name) linspace = np.linspace(weibull_min.ppf(0.001, shape, loc=0, scale=scale), weibull_min.ppf(0.999, shape, loc=0, scale=scale), 1000) # First plot PDF if theoretical_distribution is not None: subplots[0].plot(linspace, weibull_min.pdf(linspace, shape, loc=0, scale=scale), 'r-', lw=1, alpha=0.6, label='Reconstructed') subplots[0].plot(linspace, weibull_min.pdf(linspace, theoretical_shape, loc=0, scale=theoretical_scale), 'b-', lw=1, alpha=0.6, label='Theoretical') subplots[0].legend() else: subplots[0].plot(linspace, weibull_min.pdf(linspace, shape, loc=0, scale=scale), 'r-', lw=1, alpha=0.6) if times != EMPTY_LIST: if metric == 'Reliability': subplots[0].hist(times, bins=20, normed=True, histtype='stepfilled', alpha=0.2, label='Time to failures') if metric == 'Maintainability': subplots[0].hist(times, bins=20, normed=True, histtype='stepfilled', alpha=0.2, label='Time to repairs') subplots[0].legend() subplots[0].set_title('Weibull PDF') # Second plot CDF and/or Maintainability if theoretical_distribution is not None: subplots[1].plot(linspace, weibull_min.cdf(linspace, shape, loc=0, scale=scale), 'r-', lw=1, alpha=0.6, label='Reconstructed') subplots[1].plot(linspace, weibull_min.cdf(linspace, theoretical_shape, loc=0, scale=theoretical_scale), 'b-', lw=1, alpha=0.6, label='Theoretical') subplots[1].legend() else: subplots[1].plot(linspace, weibull_min.cdf(linspace, shape, loc=0, scale=scale), 'r-', lw=1, alpha=0.6) if metric == 'Reliability': subplots[1].set_title('Weibull CDF') if metric == 'Maintainability': subplots[1].set_title('Weibull CDF (Maintainability)') # Third plot Reliability if metric == 'Reliability': if theoretical_distribution is not None: subplots[2].plot( linspace, 1 - weibull_min.cdf(linspace, shape, loc=0, scale=scale), 'r-', lw=1, alpha=0.6, label='Reconstructed') subplots[2].plot(linspace, 1 - weibull_min.cdf(linspace, theoretical_shape, loc=0, scale=theoretical_scale), 'b-', lw=1, alpha=0.6, label='Theoretical') subplots[2].legend() else: subplots[2].plot( linspace, 1 - weibull_min.cdf(linspace, shape, loc=0, scale=scale), 'r-', lw=1, alpha=0.6) subplots[2].set_title(metric) #plt.show() plt.show(block=False)
def X_ppf(self, n): return weibull_min.ppf(n, self.X_shape, scale=self.X_scale, loc=self.X_loc)