Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
back confidence intervals of the transform.
Parameters
-----------
transform: function
must a function of two parameters:
``params``, an iterable that stores the parameters
``times``, a numpy vector representing some timeline
the function must use autograd imports (scipy and numpy)
alpha: float
confidence level
ci_labels: tuple
"""
alpha2 = 1 - alpha / 2.0
z = utils.inv_normal_cdf(alpha2)
df = pd.DataFrame(index=self.timeline)
# pylint: disable=no-value-for-parameter
gradient_of_transform_at_mle = make_jvp_reversemode(transform)(
self._fitted_parameters_, self.timeline.astype(float)
)
gradient_at_times = np.vstack(
[gradient_of_transform_at_mle(basis) for basis in np.eye(len(self._fitted_parameters_), dtype=float)]
)
std_cumulative_hazard = np.sqrt(
np.einsum("nj,jk,nk->n", gradient_at_times.T, self.variance_matrix_, gradient_at_times.T)
)
if ci_labels is None:
def _compute_confidence_intervals(self):
alpha2 = inv_normal_cdf((1.0 + self.alpha) / 2.0)
se = self.standard_errors_
hazards = self.hazards_.values
return pd.DataFrame(
np.r_[hazards - alpha2 * se, hazards + alpha2 * se],
index=["lower-bound", "upper-bound"],
columns=self.hazards_.columns,
)
def summary(self) -> pd.DataFrame:
"""Summary statistics describing the fit.
Set alpha property in the object before calling.
Returns
-------
df : DataFrame
Contains columns coef, np.exp(coef), se(coef), z, p, lower, upper"""
ci = 100 * (1 - self.alpha)
z = inv_normal_cdf(1 - self.alpha / 2)
with np.errstate(invalid="ignore", divide="ignore", over="ignore", under="ignore"):
df = pd.DataFrame(index=self.params_.index)
df["coef"] = self.params_
df["exp(coef)"] = self.hazard_ratios_
df["se(coef)"] = self.standard_errors_
df["coef lower %g%%" % ci] = self.confidence_intervals_["%g%% lower-bound" % ci]
df["coef upper %g%%" % ci] = self.confidence_intervals_["%g%% upper-bound" % ci]
df["exp(coef) lower %g%%" % ci] = self.hazard_ratios_ * np.exp(-z * self.standard_errors_)
df["exp(coef) upper %g%%" % ci] = self.hazard_ratios_ * np.exp(z * self.standard_errors_)
df["z"] = self._compute_z_values()
df["p"] = self._compute_p_values()
df["-log2(p)"] = -np.log2(df["p"])
return df
def _compute_confidence_intervals(self) -> pd.DataFrame:
z = utils.inv_normal_cdf(1 - self.alpha / 2)
ci = (1 - self.alpha) * 100
se = self.standard_errors_
params = self.params_.values
return pd.DataFrame(
np.c_[params - z * se, params + z * se],
index=self.params_.index,
columns=["%g%% lower-bound" % ci, "%g%% upper-bound" % ci],
)
the matplotlib axis that be edited.
"""
from matplotlib import pyplot as plt
if ax is None:
ax = plt.gca()
errorbar_kwargs.setdefault("c", "k")
errorbar_kwargs.setdefault("fmt", "s")
errorbar_kwargs.setdefault("markerfacecolor", "white")
errorbar_kwargs.setdefault("markeredgewidth", 1.25)
errorbar_kwargs.setdefault("elinewidth", 1.25)
errorbar_kwargs.setdefault("capsize", 3)
z = utils.inv_normal_cdf(1 - self.alpha / 2)
params_ = self.params_.copy()
standard_errors_ = self.standard_errors_.copy()
user_supplied_columns = False
if columns is not None:
params_ = params_.loc[:, columns]
standard_errors_ = standard_errors_.loc[:, columns]
user_supplied_columns = True
if parameter is not None:
params_ = params_.loc[parameter]
standard_errors_ = standard_errors_.loc[parameter]
columns = params_.index
hazards = params_.loc[columns].to_frame(name="coefs")
def _compute_confidence_intervals(self):
ci = 100 * (1 - self.alpha)
z = inv_normal_cdf(1 - self.alpha / 2)
se = self.standard_errors_
hazards = self.params_.values
return pd.DataFrame(
np.c_[hazards - z * se, hazards + z * se],
columns=["%g%% lower-bound" % ci, "%g%% upper-bound" % ci],
index=self.params_.index,
)