def _fit(self, X_train, y_train, X_val, y_val, time_limit=None, **kwargs):
try_import_fastai_v1()
from fastai.layers import LabelSmoothingCrossEntropy
from fastai.tabular import tabular_learner
from fastai.utils.mod_display import progress_disabled_ctx
from .callbacks import EarlyStoppingCallbackWithTimeLimit, SaveModelCallback
start_time = time.time()
self.y_scaler = self.params.get('y_scaler', None)
if self.y_scaler is not None:
self.y_scaler = copy.deepcopy(self.y_scaler)
logger.log(15,
f'Fitting Neural Network with parameters {self.params}...')
data = self.preprocess_train(X_train, y_train, X_val, y_val)
nn_metric, objective_func_name = self.__get_objective_func_name()
objective_func_name_to_monitor = self.__get_objective_func_to_monitor(
objective_func_name)
objective_optim_mode = 'min' if objective_func_name in [
'root_mean_squared_error',
'mean_squared_error',
'mean_absolute_error',
'r2' # Regression objectives
] else 'auto'
# TODO: calculate max emb concat layer size and use 1st layer as that value and 2nd in between number of classes and the value
if self.params.get('layers', None) is not None:
layers = self.params['layers']
elif self.problem_type in [REGRESSION, BINARY]:
layers = [200, 100]
else:
base_size = max(len(data.classes) * 2, 100)
layers = [base_size * 2, base_size]
loss_func = None
if self.problem_type in [BINARY, MULTICLASS
] and self.params.get('smoothing', 0.0) > 0.0:
loss_func = LabelSmoothingCrossEntropy(self.params['smoothing'])
ps = self.params['ps']
if type(ps) != list:
ps = [ps]
if time_limit:
time_elapsed = time.time() - start_time
time_left = time_limit - time_elapsed
else:
time_left = None
early_stopping_fn = partial(
EarlyStoppingCallbackWithTimeLimit,
monitor=objective_func_name_to_monitor,
mode=objective_optim_mode,
min_delta=self.params['early.stopping.min_delta'],
patience=self.params['early.stopping.patience'],
time_limit=time_left)
self.model = tabular_learner(data,
layers=layers,
ps=ps,
emb_drop=self.params['emb_drop'],
metrics=nn_metric,
loss_func=loss_func,
callback_fns=[early_stopping_fn])
logger.log(15, self.model.model)
with make_temp_directory() as temp_dir:
save_callback = SaveModelCallback(
self.model,
monitor=objective_func_name_to_monitor,
mode=objective_optim_mode,
name=self.name)
with progress_disabled_ctx(self.model) as model:
original_path = model.path
model.path = Path(temp_dir)
model.fit_one_cycle(self.params['epochs'],
self.params['lr'],
callbacks=save_callback)
# Load the best one and export it
model.load(self.name)
if objective_func_name == 'log_loss':
eval_result = model.validate()[0]
else:
eval_result = model.validate()[1].numpy().reshape(-1)[0]
logger.log(15, f'Model validation metrics: {eval_result}')
model.path = original_path
def _fit(self,
X,
y,
X_val=None,
y_val=None,
time_limit=None,
num_cpus=None,
num_gpus=0,
sample_weight=None,
**kwargs):
try_import_fastai_v1()
import torch
from fastai.layers import LabelSmoothingCrossEntropy
from fastai.tabular import tabular_learner
from fastai.utils.mod_display import progress_disabled_ctx
from fastai.core import defaults
from .callbacks import EarlyStoppingCallbackWithTimeLimit, SaveModelCallback
start_time = time.time()
if sample_weight is not None: # TODO: support
logger.log(
15,
"sample_weight not yet supported for NNFastAiTabularModel, this model will ignore them in training."
)
params = self.params.copy()
self.y_scaler = params.get('y_scaler', None)
if self.y_scaler is not None:
self.y_scaler = copy.deepcopy(self.y_scaler)
if num_cpus is None:
num_cpus = defaults.cpus
# additional workers are helping only when fork is enabled; in other mp modes, communication overhead reduces performance
num_workers = int(num_cpus / 2)
if not is_fork_enabled():
num_workers = 0
if num_gpus is not None:
if num_gpus == 0:
# TODO: Does not obviously impact inference speed
defaults.device = torch.device('cpu')
else:
defaults.device = torch.device('cuda')
logger.log(15, f'Fitting Neural Network with parameters {params}...')
data = self._preprocess_train(X,
y,
X_val,
y_val,
num_workers=num_workers)
nn_metric, objective_func_name = self.__get_objective_func_name()
objective_func_name_to_monitor = self.__get_objective_func_to_monitor(
objective_func_name)
objective_optim_mode = 'min' if objective_func_name in [
'root_mean_squared_error',
'mean_squared_error',
'mean_absolute_error',
'r2' # Regression objectives
] else 'auto'
# TODO: calculate max emb concat layer size and use 1st layer as that value and 2nd in between number of classes and the value
if params.get('layers', None) is not None:
layers = params['layers']
elif self.problem_type in [REGRESSION, BINARY]:
layers = [200, 100]
else:
base_size = max(len(data.classes) * 2, 100)
layers = [base_size * 2, base_size]
loss_func = None
if self.problem_type in [BINARY, MULTICLASS
] and params.get('smoothing', 0.0) > 0.0:
loss_func = LabelSmoothingCrossEntropy(params['smoothing'])
ps = params['ps']
if type(ps) != list:
ps = [ps]
if time_limit:
time_elapsed = time.time() - start_time
time_left = time_limit - time_elapsed
else:
time_left = None
best_epoch_stop = params.get("best_epoch",
None) # Use best epoch for refit_full.
early_stopping_fn = partial(
EarlyStoppingCallbackWithTimeLimit,
monitor=objective_func_name_to_monitor,
mode=objective_optim_mode,
min_delta=params['early.stopping.min_delta'],
patience=params['early.stopping.patience'],
time_limit=time_left,
best_epoch_stop=best_epoch_stop)
self.model = tabular_learner(data,
layers=layers,
ps=ps,
emb_drop=params['emb_drop'],
metrics=nn_metric,
loss_func=loss_func,
callback_fns=[early_stopping_fn])
logger.log(15, self.model.model)
with make_temp_directory() as temp_dir:
save_callback = SaveModelCallback(
self.model,
monitor=objective_func_name_to_monitor,
mode=objective_optim_mode,
name=self.name,
best_epoch_stop=best_epoch_stop)
with progress_disabled_ctx(self.model) as model:
original_path = model.path
model.path = Path(temp_dir)
model.fit_one_cycle(params['epochs'],
params['lr'],
callbacks=save_callback)
# Load the best one and export it
model.load(self.name)
if objective_func_name == 'log_loss':
eval_result = model.validate()[0]
else:
eval_result = model.validate()[1].numpy().reshape(-1)[0]
logger.log(15, f'Model validation metrics: {eval_result}')
model.path = original_path
self.params_trained['best_epoch'] = save_callback.best_epoch