def inference(params=None): x, _ = input_data([None, 5], name='x') y, _ = input_data([None, 5], name='y') x1, _ = fully_connected_network(x, [5, 1], name='x1') y1, _ = fully_connected_network(y, [5, 1], name='y1') d, _ = angle_distance(x1 + y1, name='d') return d
def test_input_data_rename_nodes(self): """ Test the input_data and rename_nodes functions :return: """ with tf.Session() as sess: x, _ = input_data([], 'x') y, _ = rename_nodes(x, ['y']) self.assertEqual(sess.run(y, {x[0]: 1.0})[0], 1.0)
def inference(params=None): """ This function defines the TF computational model network @return: network_output_nodes as an array of tf nodes """"" x, _ = input_data([None, 1], 'x') poly, _ = polynomial(x, 2, name='p') poly, _ = rename_nodes(poly, ['ybar']) return poly
def inference(): """ This function defines the TF computational model network @return: network_output_nodes as an array of tf nodes """ "" x, _ = input_data([None, 1], 'x') fcn, _ = fully_connected_network(x, [10, 10, 1], dropout_keep_probs=.5) # expand, _ = fully_connected_layer(x, 10, name='expand') # contract, _ = fully_connected_layer(expand, 1, name='contract') ybar, _ = rename_nodes(fcn, ['ybar']) return ybar
def _l2_diff_loss(network_output_nodes, params=None): """ Default loss is an L2 loss that creates new inputs with names 'yn' @param network_output_nodes: list of tensorflow nodes @return: a list of tensorflow nodes. This list has equal length as network_output_nodes. """ loss = [] for j, network_output_node in enumerate(network_output_nodes): y, _ = core.input_data(network_output_node.get_shape(), 'y%d' % j) loss.append( tf.sqrt( tf.reduce_mean(tf.square(tf.sub(y, network_output_node))))) return loss
def test_fully_connected_layer(self): with tf.Session() as sess: x, _ = input_data([1], 'x') y, _ = fully_connected_layer(x, 10) self.assertEqual(sess.run(y, {x[0]: 1.0})[0], 1.0)
def __init__(self, inference, training_data, loss=None, batch_size=128, data_map=None, name='model', model_output_location='/tmp', optimizer=None, train_iteration=None, train_iteration_done=_default_train_iteration_done, params=None, log_to_db=True): """ Constructor for the trainer class @type inference: function @param inference: The function that builds a network. This function has no argument and returns a list of output nodes of the network. @param training_data: @param loss: @param batch_size: @param data_map: @param name: @param model_output_location: @param optimizer: @param train_iteration: @param train_iteration_done: @param optimizer_params: """ self._model_log_db = None self._model_name = name self._model_output_location = model_output_location self._model_ckpt_filename = os.path.join( self._model_output_location, self._model_name + CHECKPOINT_FILE_EXTENSION) self._inference = inference self._loss = loss self._batch_size = batch_size self._data_map = data_map self._training_data = training_data self._params = common_utils.extend_dict(params, default_params) self._train_iteration_done = train_iteration_done self._model_graph_def = None if log_to_db: import framework.db.model_log_db as db self._model_log_db = db.ModelLogDbWriter() self._model_log_db_id = self._model_log_db.begin_training( self._model_name, self._model_output_location) with open( os.path.join(self._model_output_location, 'model_log_db_id.txt'), 'w') as f: f.write("%s\n" % self._model_log_db_id) if loss: self._loss = loss else: self._loss = Trainer._l2_diff_loss if optimizer: self._optimizer = optimizer else: self._optimizer = Trainer._adam_optimizer if train_iteration: self._train_iteration = train_iteration else: self._train_iteration = Trainer._default_train_iteration # create session and build graph self._graph = tf.Graph() self._session = tf.Session(graph=self._graph) with self._graph.as_default(): self._is_training = core.input_data([], IS_TRAINING_PLACEHOLDER_NAME, dtype=tf.bool) self._network_output_nodes = self._inference(self._params) self._learning_rate = tf.Variable(common_utils.get_dict_value( self._params, LEARNING_RATE_PARAM_NAME, DEFAULT_LEARNING_RATE), trainable=False) self._model_graph_def = copy.copy(self._graph.as_graph_def()) # loss is an array of loss functions self._loss_nodes = self._loss(self._network_output_nodes, params=self._params) # build optimizer self._optimizer_nodes = self._optimizer(self._params, self._loss_nodes, self._learning_rate)