def _log_hazard(self, params, times):
# mu_, ln_sigma_, lambda_ = params # 変更前
mu_, lambda_ = params # 変更後
ilambda_2 = 1 / lambda_ ** 2
# Z = (log(times) - mu_) / safe_exp(ln_sigma_) # 変更前
Z = (log(times) - mu_) / lambda_ # 変更後
if lambda_ > 0:
v = (
# log(lambda_) # 削除
- log(times)
# - ln_sigma_ # 削除
- gammaln(ilambda_2)
+ (lambda_ * Z - safe_exp(lambda_ * Z) - 2 * log(lambda_)) * ilambda_2
- gammainccln(ilambda_2, safe_exp(lambda_ * Z - 2 * np.log(lambda_)))
)
else:
v = (
# log(-lambda_) # 削除
- log(times)
# - ln_sigma_ # 削除
- gammaln(ilambda_2)
+ (lambda_ * Z - safe_exp(lambda_ * Z) - 2 * log(-lambda_)) * ilambda_2
- gammaincln(ilambda_2, safe_exp(lambda_ * Z - 2 * np.log(-lambda_)))
)
return v
def _cumulative_hazard(self, params, T, Xs):
lambda_params = params["lambda_"]
log_lambda_ = Xs["lambda_"] @ lambda_params
rho_params = params["rho_"]
rho_ = safe_exp(Xs["rho_"] @ rho_params)
return safe_exp(rho_ * (np.log(np.clip(T, 1e-25, np.inf)) - log_lambda_))
def _survival_function(self, params, times):
mu_, ln_sigma_, lambda_ = params
sigma_ = safe_exp(ln_sigma_)
Z = (log(times) - mu_) / sigma_
if lambda_ > 0:
return gammaincc(1 / lambda_ ** 2, safe_exp(lambda_ * Z - 2 * np.log(lambda_)))
else:
return gammainc(1 / lambda_ ** 2, safe_exp(lambda_ * Z - 2 * np.log(-lambda_)))
def _log_1m_sf(self, params, T, Xs):
alpha_params = params["alpha_"]
log_alpha_ = np.dot(Xs["alpha_"], alpha_params)
alpha_ = safe_exp(log_alpha_)
beta_params = params["beta_"]
log_beta_ = np.dot(Xs["beta_"], beta_params)
beta_ = safe_exp(log_beta_)
return -np.logaddexp(-beta_ * (np.log(T) - np.log(alpha_)), 0)
def _cumulative_hazard(self, params, times):
mu_, ln_sigma_, lambda_ = params
sigma_ = safe_exp(ln_sigma_)
Z = (log(times) - mu_) / sigma_
ilambda_2 = 1 / lambda_ ** 2
if lambda_ > 0:
v = -gammainccln(ilambda_2, safe_exp(lambda_ * Z - 2 * np.log(lambda_)))
else:
v = -gammaincln(ilambda_2, safe_exp(lambda_ * Z - 2 * np.log(-lambda_)))
return v
def _log_1m_sf(self, params, times):
mu_, ln_sigma_, lambda_ = params
sigma_ = safe_exp(ln_sigma_)
Z = (log(times) - mu_) / sigma_
if lambda_ > 0:
v = gammaincln(1 / lambda_ ** 2, safe_exp(lambda_ * Z - 2 * np.log(lambda_)))
else:
v = gammainccln(1 / lambda_ ** 2, safe_exp(lambda_ * Z - 2 * np.log(-lambda_)))
return v
def _cumulative_hazard(self, params, T, Xs):
lambda_ = Xs["lambda_"] @ params["lambda_"]
sigma_ = safe_exp(Xs["sigma_"] @ params["sigma_"])
mu_ = Xs["mu_"] @ params["mu_"]
ilambda_2 = 1 / lambda_ ** 2
Z = (log(T) - mu_) / np.clip(sigma_, 1e-10, 1e20)
exp_term = np.clip(safe_exp(lambda_ * Z - 2 * log(np.abs(lambda_))), 1e-300, np.inf)
return -np.where(lambda_ > 0, gammainccln(ilambda_2, exp_term), gammaincln(ilambda_2, exp_term))
def _cumulative_hazard(
self, params: Union[DictBox, Dict[str, np.array]], T: Union[float, np.array], Xs: DataframeSliceDict
) -> Union[np.array, ArrayBox]:
lambda_params = params["lambda_"]
log_lambda_ = Xs["lambda_"] @ lambda_params
rho_params = params["rho_"]
rho_ = safe_exp(Xs["rho_"] @ rho_params)
return safe_exp(rho_ * (np.log(np.clip(T, 1e-25, np.inf)) - log_lambda_))
def _survival_function(self, params, T, Xs):
lambda_ = np.clip(Xs["lambda_"] @ params["lambda_"], 1e-25, 1e10)
sigma_ = safe_exp(Xs["sigma_"] @ params["sigma_"])
mu_ = Xs["mu_"] @ params["mu_"]
Z = (log(T) - mu_) / sigma_
ilambda_2 = 1 / lambda_ ** 2
exp_term = safe_exp(lambda_ * Z - 2 * log(np.abs(lambda_)))
return np.where(lambda_ > 0, gammaincc(ilambda_2, exp_term), gammainc(ilambda_2, exp_term))
def _survival_function(self, params, T, Xs):
lambda_ = Xs["lambda_"] @ params["lambda_"]
sigma_ = safe_exp(Xs["sigma_"] @ params["sigma_"])
mu_ = Xs["mu_"] @ params["mu_"]
Z = (log(T) - mu_) / sigma_
ilambda_2 = 1 / lambda_**2
exp_term = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e25)
return np.where(lambda_ > 0, gammaincc(ilambda_2, exp_term),
gammainc(ilambda_2, exp_term))
def _log_hazard(self, params, T, Xs):
alpha_params = params["alpha_"]
log_alpha_ = np.dot(Xs["alpha_"], alpha_params)
alpha_ = safe_exp(log_alpha_)
beta_params = params["beta_"]
log_beta_ = np.dot(Xs["beta_"], beta_params)
beta_ = safe_exp(log_beta_)
return (log_beta_ - log_alpha_ + np.expm1(log_beta_) *
(np.log(T) - log_alpha_) -
np.logaddexp(beta_ * (np.log(T) - np.log(alpha_)), 0))
def test_safe_exp():
from lifelines.utils.safe_exp import MAX
assert safe_exp(4.0) == np.exp(4.0)
assert safe_exp(MAX) == np.exp(MAX)
assert safe_exp(MAX + 1) == np.exp(MAX)
from autograd import grad
assert grad(safe_exp)(4.0) == np.exp(4.0)
assert grad(safe_exp)(MAX) == np.exp(MAX)
assert grad(safe_exp)(MAX + 1) == np.exp(MAX)
def _cumulative_hazard(self, params, T, Xs):
# a negative sign makes the interpretation the same as other AFT models
Xbeta = -np.dot(Xs["beta_"], params["beta_"])
logT = np.log(T)
H = safe_exp(params["gamma0_"] + params["gamma1_"] * (logT + Xbeta))
for i in range(2, self.n_baseline_knots):
H *= safe_exp(
params["gamma%d_" % i]
* self.basis(logT + Xbeta, self.knots[i - 1], min_knot=self.knots[0], max_knot=self.knots[-1])
)
return H
def _cumulative_hazard(self, params, T, Xs):
Xbeta = np.dot(Xs["beta_"], params["beta_"])
logT = np.log(T)
H = safe_exp(params["gamma0_"] + params["gamma1_"] * (logT + Xbeta))
for i in range(2, self.n_baseline_knots):
H *= safe_exp(params["gamma%d_" % i] *
self.basis(logT + Xbeta,
self.knots[i - 1],
min_knot=self.knots[0],
max_knot=self.knots[-1]))
return H
def _log_hazard(self, params, T, Xs):
lambda_ = Xs["lambda_"] @ params["lambda_"]
ln_sigma_ = Xs["sigma_"] @ params["sigma_"]
mu_ = Xs["mu_"] @ params["mu_"]
ilambda_2 = 1 / lambda_**2
Z = (log(T) - mu_) / np.clip(safe_exp(ln_sigma_), 0, 1e20)
exp_term = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e25)
return (log(np.abs(lambda_)) - log(T) - ln_sigma_ -
gammaln(ilambda_2) +
(lambda_ * Z - 2 * log(np.abs(lambda_))) * ilambda_2 -
exp_term -
np.where(lambda_ > 0, gammainccln(ilambda_2, exp_term),
gammaincln(ilambda_2, exp_term)))
def _log_1m_sf(self, params, times):
mu_, ln_sigma_, lambda_ = params
sigma_ = safe_exp(ln_sigma_)
ilambda_2 = 1 / lambda_**2
Z = (log(times) - mu_) / sigma_
clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-15, 1e20)
if lambda_ > 0:
v = gammaincln(1 / lambda_**2, clipped_exp)
elif lambda_ < 0:
v = gammainccln(1 / lambda_**2, clipped_exp)
else:
v = norm.logcdf(Z)
return v
def _cumulative_hazard(self, params, times):
mu_, ln_sigma_, lambda_ = params
sigma_ = safe_exp(ln_sigma_)
Z = (log(times) - mu_) / sigma_
ilambda_2 = 1 / lambda_**2
clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-300, 1e20)
if lambda_ > 0:
v = -gammainccln(ilambda_2, clipped_exp)
elif lambda_ < 0:
v = -gammaincln(ilambda_2, clipped_exp)
else:
v = -norm.logsf(Z)
return v
def _log_hazard(self, params, times):
mu_, ln_sigma_, lambda_ = params
ilambda_2 = 1 / lambda_**2
Z = (log(times) - mu_) / safe_exp(ln_sigma_)
if lambda_ > 0:
v = (log(lambda_) - log(times) - ln_sigma_ - gammaln(ilambda_2) +
(lambda_ * Z - safe_exp(lambda_ * Z) - 2 * log(lambda_)) *
ilambda_2 - gammainccln(
ilambda_2, safe_exp(lambda_ * Z - 2 * np.log(lambda_))))
else:
v = (log(-lambda_) - log(times) - ln_sigma_ - gammaln(ilambda_2) +
(lambda_ * Z - safe_exp(lambda_ * Z) - 2 * log(-lambda_)) *
ilambda_2 - gammaincln(
ilambda_2, safe_exp(lambda_ * Z - 2 * np.log(-lambda_))))
return v
def _cumulative_hazard(self, params, T, Xs):
n = T.shape[0]
T = T.reshape((n, 1))
M = np.minimum(np.tile(self.breakpoints, (n, 1)), T)
M = np.hstack([M[:, tuple([0])], np.diff(M, axis=1)])
lambdas_ = np.array([safe_exp(-np.dot(Xs[param], params[param])) for param in self._fitted_parameter_names])
return (M * lambdas_.T).sum(1)
def _survival_function(
self, params: Union[DictBox, Dict[str,
np.array]], T: Union[float,
np.array],
Xs: DataframeSliceDict) -> Union[np.array, ArrayBox]:
ch = self._cumulative_hazard(params, T, Xs)
return safe_exp(-ch)
def _survival_function(self, params, times):
mu_, ln_sigma_, lambda_ = params
sigma_ = safe_exp(ln_sigma_)
Z = (log(times) - mu_) / sigma_
clipped_exp = np.clip(safe_exp(lambda_ * Z) / lambda_**2, 1e-15, 1e20)
ilambda_2 = 1 / lambda_**2
if lambda_ > 0:
v = gammaincc(ilambda_2, clipped_exp)
elif lambda_ < 0:
v = gammainc(ilambda_2, clipped_exp)
else:
v = norm.sf(Z)
# never return a 0
return np.clip(v, 1e-50, 1 - 1e-50)
def _log_hazard(self, params, times):
mu_, ln_sigma_, lambda_ = params
ilambda_2 = 1 / lambda_**2
Z = (log(times) - mu_) / safe_exp(ln_sigma_)
clipped_exp = np.clip(safe_exp(lambda_ * Z) * ilambda_2, 1e-15, 1e20)
if lambda_ > 0:
v = (log(lambda_) - log(times) - ln_sigma_ - gammaln(ilambda_2) +
-2 * log(lambda_) * ilambda_2 - clipped_exp + Z / lambda_ -
gammainccln(ilambda_2, clipped_exp))
elif lambda_ < 0:
v = (log(-lambda_) - log(times) - ln_sigma_ - gammaln(ilambda_2) -
2 * log(-lambda_) * ilambda_2 - clipped_exp + Z / lambda_ -
gammaincln(ilambda_2, clipped_exp))
else:
v = norm.logpdf(Z, loc=0,
scale=1) - ln_sigma_ - log(times) - norm.logsf(Z)
return v
def _cumulative_hazard(self, params, T, Xs):
alpha_params = params["alpha_"]
alpha_ = safe_exp(np.dot(Xs["alpha_"], alpha_params))
beta_params = params["beta_"]
beta_ = np.exp(np.dot(Xs["beta_"], beta_params))
return np.logaddexp(
beta_ * (np.log(np.clip(T, 1e-25, np.inf)) - np.log(alpha_)), 0)
def _cumulative_hazard(self, params, T, Xs):
mu_params = params["mu_"]
mu_ = np.dot(Xs["mu_"], mu_params)
sigma_params = params["sigma_"]
sigma_ = safe_exp(np.dot(Xs["sigma_"], sigma_params))
Z = (np.log(T) - mu_) / sigma_
return -norm.logsf(Z)
def _log_1m_sf(self, params, T, Xs):
mu_params = params["mu_"]
mu_ = np.dot(Xs["mu_"], mu_params)
sigma_params = params["sigma_"]
log_sigma_ = np.dot(Xs["sigma_"], sigma_params)
sigma_ = safe_exp(log_sigma_)
Z = (np.log(T) - mu_) / sigma_
return norm.logcdf(Z)
def _cumulative_hazard(
self, params: Union[DictBox, Dict[str, ndarray]], T: Union[float, ndarray], Xs: DataframeSlicer
) -> Union[ndarray, ArrayBox]:
mu_params = params["mu_"]
mu_ = np.dot(Xs["mu_"], mu_params)
sigma_params = params["sigma_"]
sigma_ = safe_exp(np.dot(Xs["sigma_"], sigma_params))
Z = (np.log(T) - mu_) / sigma_
return -norm.logsf(Z)
def _log_hazard(self, params: DictBox, T: Union[float, ndarray], Xs: DataframeSlicer) -> ArrayBox:
mu_params = params["mu_"]
mu_ = np.dot(Xs["mu_"], mu_params)
sigma_params = params["sigma_"]
log_sigma_ = np.dot(Xs["sigma_"], sigma_params)
sigma_ = safe_exp(log_sigma_)
Z = (np.log(T) - mu_) / sigma_
return norm.logpdf(Z) - log_sigma_ - np.log(T) - norm.logsf(Z)
def _log_hazard(self, params, T, Xs):
mu_params = params["mu_"]
mu_ = np.dot(Xs["mu_"], mu_params)
sigma_params = params["sigma_"]
log_sigma_ = np.dot(Xs["sigma_"], sigma_params)
sigma_ = safe_exp(log_sigma_)
Z = (np.log(T) - mu_) / sigma_
return norm.logpdf(Z) - log_sigma_ - np.log(T) - norm.logsf(Z)
def _cumulative_hazard(self, params, times):
lambda_, rho_ = params
return safe_exp(
rho_ * (np.log(np.clip(times, 1e-25, np.inf)) - np.log(lambda_)))
