def fit(self,
X,
T,
E,
init_method='glorot_uniform',
optimizer='adam',
lr=1e-4,
num_epochs=1000,
dropout=0.2,
batch_normalization=False,
bn_and_dropout=False,
l2_reg=1e-5,
verbose=True):
"""
Fit the estimator based on the given parameters.
Parameters:
-----------
* `X` : **array-like**, *shape=(n_samples, n_features)* --
The input samples.
* `T` : **array-like** --
The target values describing when the event of interest or censoring
occurred.
* `E` : **array-like** --
The values that indicate if the event of interest occurred i.e.:
E[i]=1 corresponds to an event, and E[i] = 0 means censoring,
for all i.
* `init_method` : **str** *(default = 'glorot_uniform')* --
Initialization method to use. Here are the possible options:
* `glorot_uniform`: Glorot/Xavier uniform initializer
* `he_uniform`: He uniform variance scaling initializer
* `uniform`: Initializing tensors with uniform (-1, 1) distribution
* `glorot_normal`: Glorot normal initializer,
* `he_normal`: He normal initializer.
* `normal`: Initializing tensors with standard normal distribution
* `ones`: Initializing tensors to 1
* `zeros`: Initializing tensors to 0
* `orthogonal`: Initializing tensors with a orthogonal matrix,
* `optimizer`: **str** *(default = 'adam')* --
iterative method for optimizing a differentiable objective function.
Here are the possible options:
- `adadelta`
- `adagrad`
- `adam`
- `adamax`
- `rmsprop`
- `sparseadam`
- `sgd`
* `lr`: **float** *(default=1e-4)* --
learning rate used in the optimization
* `num_epochs`: **int** *(default=1000)* --
The number of iterations in the optimization
* `dropout`: **float** *(default=0.5)* --
Randomly sets a fraction rate of input units to 0
at each update during training time, which helps prevent overfitting.
* `l2_reg`: **float** *(default=1e-4)* --
L2 regularization parameter for the model coefficients
* `batch_normalization`: **bool** *(default=True)* --
Applying Batch Normalization or not
* `bn_and_dropout`: **bool** *(default=False)* --
Applying Batch Normalization and Dropout at the same time
* `verbose`: **bool** *(default=True)* --
Whether or not producing detailed logging about the modeling
Example:
--------
#### 1 - Importing packages
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from pysurvival.models.simulations import SimulationModel
from pysurvival.models.semi_parametric import NonLinearCoxPHModel
from pysurvival.utils.metrics import concordance_index
from pysurvival.utils.display import integrated_brier_score
#%matplotlib inline # To use with Jupyter notebooks
#### 2 - Generating the dataset from a nonlinear Weibull parametric model
# Initializing the simulation model
sim = SimulationModel( survival_distribution = 'weibull',
risk_type = 'Gaussian',
censored_parameter = 2.1,
alpha = 0.1, beta=3.2 )
# Generating N random samples
N = 1000
dataset = sim.generate_data(num_samples = N, num_features=3)
# Showing a few data-points
dataset.head(2)
#### 3 - Creating the modeling dataset
# Defining the features
features = sim.features
# Building training and testing sets #
index_train, index_test = train_test_split( range(N), test_size = 0.2)
data_train = dataset.loc[index_train].reset_index( drop = True )
data_test = dataset.loc[index_test].reset_index( drop = True )
# Creating the X, T and E input
X_train, X_test = data_train[features], data_test[features]
T_train, T_test = data_train['time'].values, data_test['time'].values
E_train, E_test = data_train['event'].values, data_test['event'].values
#### 4 - Creating an instance of the NonLinear CoxPH model and fitting
# the data.
# Defining the MLP structure. Here we will build a 1-hidden layer
# with 150 units and `BentIdentity` as its activation function
structure = [ {'activation': 'BentIdentity', 'num_units': 150}, ]
# Building the model
nonlinear_coxph = NonLinearCoxPHModel(structure=structure)
nonlinear_coxph.fit(X_train, T_train, E_train, lr=1e-3,
init_method='xav_uniform')
#### 5 - Cross Validation / Model Performances
c_index = concordance_index(nonlinear_coxph, X_test, T_test, E_test)
print('C-index: {:.2f}'.format(c_index))
ibs = integrated_brier_score(nonlinear_coxph, X_test, T_test, E_test,
t_max=10, figure_size=(20, 6.5) )
"""
# Checking data format (i.e.: transforming into numpy array)
X, T, E = utils.check_data(X, T, E)
# Extracting data parameters
N, self.num_vars = X.shape
input_shape = self.num_vars
# Scaling data
if self.auto_scaler:
X_original = self.scaler.fit_transform(X)
# Sorting X, T, E in descending order according to T
order = np.argsort(-T)
T = T[order]
E = E[order]
X_original = X_original[order, :]
self.times = np.unique(T[E.astype(bool)])
self.nb_times = len(self.times)
self.get_time_buckets()
# Initializing the model
model = nn.NeuralNet(input_shape, 1, self.structure, init_method,
dropout, batch_normalization, bn_and_dropout)
# Looping through the data to calculate the loss
X = torch.cuda.FloatTensor(X_original)
# Computing the Risk and Fail tensors
Risk, Fail = self.risk_fail_matrix(T, E)
Risk = torch.cuda.FloatTensor(Risk)
Fail = torch.cuda.FloatTensor(Fail)
# Computing Efron's matrices
Efron_coef, Efron_one, Efron_anti_one = self.efron_matrix()
Efron_coef = torch.cuda.FloatTensor(Efron_coef)
Efron_one = torch.cuda.FloatTensor(Efron_one)
Efron_anti_one = torch.cuda.FloatTensor(Efron_anti_one)
# Performing order 1 optimization
model, loss_values = opt.optimize(self.loss_function,
model,
optimizer,
lr,
num_epochs,
verbose,
X=X,
Risk=Risk,
Fail=Fail,
Efron_coef=Efron_coef,
Efron_one=Efron_one,
Efron_anti_one=Efron_anti_one,
l2_reg=l2_reg)
# Saving attributes
self.model = model.eval()
self.loss_values = loss_values
# Computing baseline functions
x = X_original
x = torch.cuda.FloatTensor(x)
# Calculating risk_score
score = np.exp(
self.model(torch.cuda.FloatTensor(x)).data.cpu().numpy().flatten())
baselines = _baseline_functions(score, T, E)
# Saving the Cython attributes in the Python object
self.times = np.array(baselines[0])
self.baseline_hazard = np.array(baselines[1])
self.baseline_survival = np.array(baselines[2])
return self
def fit(self,
X,
T,
E,
init_method='glorot_uniform',
optimizer='adam',
lr=1e-4,
num_epochs=1000,
dropout=0.2,
l2_reg=1e-2,
l2_smooth=1e-2,
batch_normalization=False,
bn_and_dropout=False,
verbose=True,
extra_pct_time=0.1,
is_min_time_zero=True,
max_norm=1.0,
min_clamp_value=1e-8,
max_clamp_value=torch.finfo(torch.float32).max - 1):
""" Fit the estimator based on the given parameters.
Parameters:
-----------
* `X` : **array-like**, *shape=(n_samples, n_features)* --
The input samples.
* `T` : **array-like** --
The target values describing when the event of interest or censoring
occurred.
* `E` : **array-like** --
The values that indicate if the event of interest occurred i.e.:
E[i]=1 corresponds to an event, and E[i] = 0 means censoring,
for all i.
* `init_method` : **str** *(default = 'glorot_uniform')* --
Initialization method to use. Here are the possible options:
* `glorot_uniform`: Glorot/Xavier uniform initializer
* `he_uniform`: He uniform variance scaling initializer
* `uniform`: Initializing tensors with uniform (-1, 1) distribution
* `glorot_normal`: Glorot normal initializer,
* `he_normal`: He normal initializer.
* `normal`: Initializing tensors with standard normal distribution
* `ones`: Initializing tensors to 1
* `zeros`: Initializing tensors to 0
* `orthogonal`: Initializing tensors with a orthogonal matrix,
* `optimizer`: **str** *(default = 'adam')* --
iterative method for optimizing a differentiable objective function.
Here are the possible options:
- `adadelta`
- `adagrad`
- `adam`
- `adamax`
- `rmsprop`
- `sparseadam`
- `sgd`
* `lr`: **float** *(default=1e-4)* --
learning rate used in the optimization
* `num_epochs`: **int** *(default=1000)* --
The number of iterations in the optimization
* `dropout`: **float** *(default=0.5)* --
Randomly sets a fraction rate of input units to 0
at each update during training time, which helps prevent overfitting.
* `l2_reg`: **float** *(default=1e-4)* --
L2 regularization parameter for the model coefficients
* `l2_smooth`: **float** *(default=1e-4)* --
Second L2 regularizer that ensures the parameters vary smoothly
across consecutive time points.
* `batch_normalization`: **bool** *(default=True)* --
Applying Batch Normalization or not
* `bn_and_dropout`: **bool** *(default=False)* --
Applying Batch Normalization and Dropout at the same time
* `display_loss`: **bool** *(default=True)* --
Whether or not showing the loss function values at each update
* `verbose`: **bool** *(default=True)* --
Whether or not producing detailed logging about the modeling
* `extra_pct_time`: **float** *(default=0.1)* --
Providing an extra fraction of time in the time axis
* `is_min_time_zero`: **bool** *(default=True)* --
Whether the the time axis starts at 0
* `max_norm`: **float** *(default=1.0)* --
Max l2 norm for gradient clipping
**Returns:**
* self : object
Example:
--------
#### 1 - Importing packages
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from pysurvival.models.simulations import SimulationModel
from pysurvival.models.multi_task import LinearMultiTaskModel
from pysurvival.utils.metrics import concordance_index
#%matplotlib inline # To use with Jupyter notebooks
#### 2 - Generating the dataset from a Weibull parametric model
# Initializing the simulation model
sim = SimulationModel( survival_distribution = 'Weibull',
risk_type = 'linear',
censored_parameter = 10.0,
alpha = .01, beta = 3.0 )
# Generating N random samples
N = 1000
dataset = sim.generate_data(num_samples = N, num_features = 3)
# Showing a few data-points
time_column = 'time'
event_column = 'event'
dataset.head(2)
#### 3 - Creating the modeling dataset
# Defining the features
features = sim.features
# Building training and testing sets #
index_train, index_test = train_test_split( range(N), test_size = 0.2)
data_train = dataset.loc[index_train].reset_index( drop = True )
data_test = dataset.loc[index_test].reset_index( drop = True )
# Creating the X, T and E input
X_train, X_test = data_train[features], data_test[features]
T_train, T_test = data_train['time'].values, data_test['time'].values
E_train, E_test = data_train['event'].values, data_test['event'].values
#### 4 - Initializing a MTLR model and fitting the data.
# Building a Linear model
mtlr = LinearMultiTaskModel(bins=50)
mtlr.fit(X_train, T_train, E_train, lr=5e-3, init_method='orthogonal')
# Building a Neural MTLR
# structure = [ {'activation': 'Swish', 'num_units': 150}, ]
# mtlr = NeuralMultiTaskModel(structure=structure, bins=150)
# mtlr.fit(X_train, T_train, E_train, lr=5e-3, init_method='adam')
#### 5 - Cross Validation / Model Performances
c_index = concordance_index(mtlr, X_test, T_test, E_test) #0.95
print('C-index: {:.2f}'.format(c_index))
"""
# Checking data format (i.e.: transforming into numpy array)
X, T, E = utils.check_data(X, T, E)
input_shape = []
# Extracting data parameters
if isinstance(X, list):
nb_inputs = len(X)
for data in X:
nb_units, num_vars = data.shape
input_shape.append(num_vars)
# Scaling data
if self.auto_scaler:
for index, data in enumerate(X):
X[index] = self.scaler.fit_transform(data)
else:
nb_inputs = 1
nb_units, self.num_vars = X.shape
input_shape.append(self.num_vars)
# Scaling data
if self.auto_scaler:
X = self.scaler.fit_transform(X)
# Building the time axis, time buckets and output Y
X_cens, X_uncens, Y_cens, Y_uncens \
= self.compute_XY(X, T, E, is_min_time_zero, extra_pct_time)
# Initializing the model
model = nn.NeuralNet(input_shape, self.num_times, self.structure,
init_method, dropout, batch_normalization,
bn_and_dropout)
# Creating the Triangular matrix
Triangle = np.tri(self.num_times, self.num_times + 1, dtype=np.float32)
Triangle = torch.FloatTensor(Triangle)
if torch.cuda.is_available():
model = model.cuda()
Triangle = Triangle.cuda()
# Performing order 1 optimization
model, loss_values = opt.optimize(self.loss_function,
model,
optimizer,
lr,
num_epochs,
verbose,
X_cens=X_cens,
X_uncens=X_uncens,
Y_cens=Y_cens,
Y_uncens=Y_uncens,
Triangle=Triangle,
l2_reg=l2_reg,
l2_smooth=l2_smooth,
max_norm=max_norm,
min_clamp_value=min_clamp_value,
max_clamp_value=max_clamp_value)
# Saving attributes
self.model = model.eval()
self.loss_values = loss_values
return self
def fit(self,
X,
T,
E,
init_method='glorot_uniform',
optimizer='adam',
lr=1e-4,
num_epochs=1000,
l2_reg=1e-2,
verbose=True,
is_min_time_zero=True,
extra_pct_time=0.1):
"""
Fit the estimator based on the given parameters.
Parameters:
-----------
* `X` : **array-like**, *shape=(n_samples, n_features)* --
The input samples.
* `T` : **array-like** --
The target values describing when the event of interest or censoring
occurred.
* `E` : **array-like** --
The values that indicate if the event of interest occurred i.e.:
E[i]=1 corresponds to an event, and E[i] = 0 means censoring,
for all i.
* `init_method` : **str** *(default = 'glorot_uniform')* --
Initialization method to use. Here are the possible options:
* `glorot_uniform`: Glorot/Xavier uniform initializer
* `he_uniform`: He uniform variance scaling initializer
* `uniform`: Initializing tensors with uniform (-1, 1) distribution
* `glorot_normal`: Glorot normal initializer,
* `he_normal`: He normal initializer.
* `normal`: Initializing tensors with standard normal distribution
* `ones`: Initializing tensors to 1
* `zeros`: Initializing tensors to 0
* `orthogonal`: Initializing tensors with a orthogonal matrix,
* `optimizer`: **str** *(default = 'adam')* --
iterative method for optimizing a differentiable objective function.
Here are the possible options:
- `adadelta`
- `adagrad`
- `adam`
- `adamax`
- `rmsprop`
- `sparseadam`
- `sgd`
* `lr`: **float** *(default=1e-4)* --
learning rate used in the optimization
* `num_epochs`: **int** *(default=1000)* --
The number of iterations in the optimization
* `l2_reg`: **float** *(default=1e-4)* --
L2 regularization parameter for the model coefficients
* `verbose`: **bool** *(default=True)* --
Whether or not producing detailed logging about the modeling
* `extra_pct_time`: **float** *(default=0.1)* --
Providing an extra fraction of time in the time axis
* `is_min_time_zero`: **bool** *(default=True)* --
Whether the the time axis starts at 0
Returns:
--------
* self : object
Example:
--------
#### 1 - Importing packages
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from pysurvival.models.simulations import SimulationModel
from pysurvival.models.parametric import GompertzModel
from pysurvival.utils.metrics import concordance_index
from pysurvival.utils.display import integrated_brier_score
#%matplotlib inline # To use with Jupyter notebooks
#### 2 - Generating the dataset from a Gompertz parametric model
# Initializing the simulation model
sim = SimulationModel( survival_distribution = 'Gompertz',
risk_type = 'linear',
censored_parameter = 10.0,
alpha = .01, beta = 3.0 )
# Generating N random samples
N = 1000
dataset = sim.generate_data(num_samples = N, num_features = 3)
# Showing a few data-points
time_column = 'time'
event_column = 'event'
dataset.head(2)
#### 3 - Creating the modeling dataset
# Defining the features
features = sim.features
# Building training and testing sets #
index_train, index_test = train_test_split( range(N), test_size = 0.2)
data_train = dataset.loc[index_train].reset_index( drop = True )
data_test = dataset.loc[index_test].reset_index( drop = True )
# Creating the X, T and E input
X_train, X_test = data_train[features], data_test[features]
T_train, T_test = data_train['time'].values, data_test['time'].values
E_train, E_test = data_train['event'].values, data_test['event'].values
#### 4 - Creating an instance of the Gompertz model and fitting the data
# Building the model
gomp_model = GompertzModel()
gomp_model.fit(X_train, T_train, E_train, lr=1e-2, init_method='zeros',
optimizer ='adam', l2_reg = 1e-3, num_epochs=2000)
#### 5 - Cross Validation / Model Performances
c_index = concordance_index(gomp_model, X_test, T_test, E_test) #0.8
print('C-index: {:.2f}'.format(c_index))
ibs = integrated_brier_score(gomp_model, X_test, T_test, E_test,
t_max=30, figure_size=(20, 6.5) )
"""
# Checking data format (i.e.: transforming into numpy array)
X, T, E = utils.check_data(X, T, E)
T = np.maximum(T, 1e-6)
self.get_times(T, is_min_time_zero, extra_pct_time)
# Extracting data parameters
nb_units, self.num_vars = X.shape
input_shape = self.num_vars
# Scaling data
if self.auto_scaler:
X = self.scaler.fit_transform(X)
# Does the model need a parameter called Beta
is_beta_used = True
init_alpha = 1.
if self.name == 'ExponentialModel':
is_beta_used = False
if self.name == 'GompertzModel':
init_alpha = 1000.
# Initializing the model
model = nn.ParametricNet(input_shape, init_method, init_alpha,
is_beta_used)
# Trasnforming the inputs into tensors
X = torch.FloatTensor(X)
T = torch.FloatTensor(T.reshape(-1, 1))
E = torch.FloatTensor(E.reshape(-1, 1))
# Performing order 1 optimization
model, loss_values = opt.optimize(self.loss_function,
model,
optimizer,
lr,
num_epochs,
verbose,
X=X,
T=T,
E=E,
l2_reg=l2_reg)
# Saving attributes
self.model = model.eval()
self.loss_values = loss_values
# Calculating the AIC
self.aic = 2 * self.loss_values[-1]
self.aic -= 2 * (self.num_vars + 1 + is_beta_used * 1. - 1)
return self