Trainer Class Reference

Public Member Functions
def	__init__ (self, model, data_set, log_dir=None, save_name=None, monitoring_size=10000)
def	train_model (self)

Public Attributes
	model
	model
	data_set
	dataset
	monitoring_size
	monitoring size
	log_dir
	log dir
	termination_criterion
	termination criterion
	current_epoch
	initialise current epoch
	best_epoch
	initialise best epoch
	save_name
	set the path and name for saving the weightfiles
	train_monitor
	train_monitor
	valid_monitor
	test monitor
	train_writer
	tf.summary.writer for training
	valid_writer
	tf.summary.writer for validation
	optimizer
	set optimizer for this epoch

Protected Member Functions
def	_prepare_monitoring (self)
def	_prepare_tensorboard (self, log_dir)
def	_train_epoch (self, current_epoch)
def	_save_best_state (self, cross_entropy)
def	_closing_ops (self)

Protected Attributes
	_time
	current time

Detailed Description

handling the training of the network model

Definition at line 450 of file tensorflow_dnn_model.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			model,
			data_set,
			log_dir = None,
			save_name = None,
			monitoring_size = 10000
	)

class to train a predefined model
:param model: DefaultModel obj
:param data_set: TFData obj
:param log_dir: str, directory name of tensorboard logging
:param save_name: str, path and name for saving the weightfiles
:param monitoring_size: int, number of events of training fraction used for monitoring

Definition at line 455 of file tensorflow_dnn_model.py.

                 monitoring_size=10000):
        """
        class to train a predefined model
        :param model: DefaultModel obj
        :param data_set: TFData obj
        :param log_dir: str, directory name of tensorboard logging
        :param save_name: str, path and name for saving the weightfiles
        :param monitoring_size: int, number of events of training fraction used for monitoring
        """
 
        
        self._time = time.time()
 
        
        self.model = model
 
        
        self.data_set = data_set
        self.model.initialize(data_set)
 
        
        self.monitoring_size = monitoring_size
 
        
        self.log_dir = log_dir
 
        
        self.termination_criterion = self.model.termination_criterion
 
        
        self.current_epoch = 0
 
        
        self.best_epoch = -np.inf
 
        if log_dir is not None:
            self._prepare_tensorboard(log_dir)
 
        if save_name is None:
            time_str = time.strftime("%Y%m%d-%H%M%S")
            save_name = os.path.join(os.getcwd(), '_'.join([time_str, 'model']))
 
        
        self.save_name = save_name
 
        self._prepare_monitoring()
        return
 

Member Function Documentation

_closing_ops()

def _closing_ops (   self )

protected

closing operations

Definition at line 625 of file tensorflow_dnn_model.py.

    def _closing_ops(self):
        """
        closing operations
        """
        if self.log_dir is not None:
            self.train_writer.close()
            self.valid_writer.close()
        return
 

_prepare_monitoring()

def _prepare_monitoring (   self )

protected

checking dataset sizes for evaluation. These samples are used after each epoch to collect
summary statistics and test early stopping criteria.

Definition at line 508 of file tensorflow_dnn_model.py.

    def _prepare_monitoring(self):
        """
        checking dataset sizes for evaluation. These samples are used after each epoch to collect
        summary statistics and test early stopping criteria.
        """
        
        self.train_monitor = -1
        
        self.valid_monitor = -1
        if self.data_set.train_events > self.monitoring_size:
            self.train_monitor = self.monitoring_size
 
        if self.data_set.valid_events > self.monitoring_size:
            self.valid_monitor = self.monitoring_size
        return
 

_prepare_tensorboard()

def _prepare_tensorboard (   self,   log_dir  )

protected

prepare tensorboard

Definition at line 524 of file tensorflow_dnn_model.py.

    def _prepare_tensorboard(self, log_dir):
        """
        prepare tensorboard
        """
        log_dir_train = os.path.join(log_dir, 'train')
        log_dir_valid = os.path.join(log_dir, 'valid')
 
        
        self.train_writer = tf.summary.create_file_writer(log_dir_train)
 
        
        self.valid_writer = tf.summary.create_file_writer(log_dir_valid)
        return
 

_save_best_state()

def _save_best_state (   self,   cross_entropy  )

protected

save model as a checkpoint only if a global minimum is reached on validation sample
:return:

Definition at line 607 of file tensorflow_dnn_model.py.

    def _save_best_state(self, cross_entropy):
        """
        save model as a checkpoint only if a global minimum is reached on validation sample
        :return:
        """
        # current state - do we need this?
        checkpoint = tf.train.Checkpoint(self.model)
        checkpoint.save(self.save_name.replace('model', 'model_current'))
 
        # check for a not set best value
        if self.model.best_value == np.inf:
            return
 
        if cross_entropy < self.model.best_value:
            self.best_epoch = self.current_epoch
            checkpoint.save(self.save_name)
        return
 

_train_epoch()

def _train_epoch (   self,   current_epoch  )

protected

train epoch

Definition at line 538 of file tensorflow_dnn_model.py.

    def _train_epoch(self, current_epoch):
        """
        train epoch
        """
        
        self.optimizer = self.model.get_optimizer(current_epoch)
 
        batch_iter = self.data_set.batch_iterator()
 
        t_range = trange(self.data_set.batches)
        t_range.set_description(f'Epoch {current_epoch:4d}')
        for i in t_range:
 
            batch = next(batch_iter)
 
            batch_x = batch[0]
            batch_y = batch[1]
 
            with tf.GradientTape() as tape:
                loss, _ = self.model.loss(self.model(batch_x), batch_y)
                grads = tape.gradient(loss, self.model.trainable_variables)
 
            self.optimizer.apply_gradients(zip(grads, self.model.trainable_variables))
 
            # write the learning rate and momentum to the tensorbord log
            if self.log_dir is not None:
                with self.train_writer.as_default():
                    tf.summary.scalar('learning_rate', self.model._get_learning_rate(), step=self.model.global_step)
                    tf.summary.scalar('momentum', self.model._get_momentum(), step=self.model.global_step)
                    self.train_writer.flush()
 
            self.model.global_step.assign_add(1)
 
        train_x = self.data_set.train_x[:self.train_monitor]
        train_y = self.data_set.train_y[:self.train_monitor]
 
        valid_x = self.data_set.valid_x[:self.valid_monitor]
        valid_y = self.data_set.valid_y[:self.valid_monitor]
 
        # run the training and validation samples to collect statistics
        train_loss, train_cross_entropy = self.model.loss(self.model(train_x), train_y)
        valid_loss, valid_cross_entropy = self.model.loss(self.model(valid_x), valid_y)
 
        # if we have a log_dir set write extra summary information
        if self.log_dir is not None:
            with self.train_writer.as_default():
                tf.summary.scalar('loss', train_loss, step=current_epoch)
                tf.summary.scalar('cross_entropy', train_cross_entropy, step=current_epoch)
 
                # this is now at the end of each epoch
                tf.summary.scalar('epoch_learning_rate', self.model._get_learning_rate(), step=current_epoch)
                tf.summary.scalar('epoch_momentum', self.model._get_momentum(), step=current_epoch)
                self.train_writer.flush()
 
            # write all the model parameters to the summary file too
            self.model.mlp.variables_to_writer(current_epoch, self.train_writer)
 
            with self.valid_writer.as_default():
                tf.summary.scalar('loss', valid_loss, step=current_epoch)
                tf.summary.scalar('cross_entropy', valid_cross_entropy, step=current_epoch)
                tf.summary.scalar('best_epoch', self.best_epoch, step=current_epoch)
                self.valid_writer.flush()
 
        # update time
        self._time = time.time()
        self.current_epoch += 1
 
        return valid_cross_entropy
 

train_model()

def train_model

(

self

)

train model

Definition at line 634 of file tensorflow_dnn_model.py.

    def train_model(self):
        """
        train model
        """
        for epoch in range(self.model.max_epochs):
            valid_cross_entropy = self._train_epoch(epoch)
 
            self._save_best_state(valid_cross_entropy)
 
            if self.termination_criterion(valid_cross_entropy, epoch):
                break
 
        self._closing_ops()
        return

Member Data Documentation

_time

_time

protected

current time

Definition at line 471 of file tensorflow_dnn_model.py.

best_epoch

best_epoch

initialise best epoch

Definition at line 493 of file tensorflow_dnn_model.py.

current_epoch

current_epoch

initialise current epoch

Definition at line 490 of file tensorflow_dnn_model.py.

data_set

data_set

dataset

Definition at line 477 of file tensorflow_dnn_model.py.

log_dir

log_dir

log dir

Definition at line 484 of file tensorflow_dnn_model.py.

model

model

model

Definition at line 474 of file tensorflow_dnn_model.py.

monitoring_size

monitoring_size

monitoring size

Definition at line 481 of file tensorflow_dnn_model.py.

optimizer

optimizer

set optimizer for this epoch

Definition at line 543 of file tensorflow_dnn_model.py.

save_name

save_name

set the path and name for saving the weightfiles

Definition at line 503 of file tensorflow_dnn_model.py.

termination_criterion

termination_criterion

termination criterion

Definition at line 487 of file tensorflow_dnn_model.py.

train_monitor

train_monitor

train_monitor

Definition at line 514 of file tensorflow_dnn_model.py.

train_writer

train_writer

tf.summary.writer for training

Definition at line 532 of file tensorflow_dnn_model.py.

valid_monitor

valid_monitor

test monitor

Definition at line 516 of file tensorflow_dnn_model.py.

valid_writer

valid_writer

tf.summary.writer for validation

Definition at line 535 of file tensorflow_dnn_model.py.

---

The documentation for this class was generated from the following file:

• analysis/scripts/dft/tensorflow_dnn_model.py