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_)))