def __init__(self, predicted, target, name=None): MComputeNode.__init__(self, name) self.predicted = predicted self.target = target self._add_upstream_nodes([predicted, target]) self.predicted_logs = None self.predicted_fixed = None
def __init__(self, prediction_source: MComputeNode, target_source: MComputeNode, name: str = None): MComputeNode.__init__(self, name) self.prediction_node = prediction_source self.target_node = target_source self._add_upstream_nodes([prediction_source, target_source]) self.probabilities = None
def __init__(self, input_node, name=None): r""" :param pred: mxn shape where m is output dimension (categories) and n is the number of instances in the batch :param target: mxn one hot vectors where m in number of categories along 0 axis, and n is the number of instances in the batch (axis=1) :param name: """ MComputeNode.__init__(self, name) self.input_node = input_node self._add_upstream_nodes([input_node]) self.epsilon = 1e-15
def __init__(self, predicted: MComputeNode, target: MComputeNode, name: str = None): r""" :param predicted: predicted values for different classes :param target: target values as one hot vector :param name: """ MComputeNode.__init__(self, name) self.predicted = predicted self.target = target self._add_upstream_nodes([predicted, target])
def __init__(self, x_node: MComputeNode, prev_rnn_node: RnnCell, w: SharedParam, w_b: SharedParam, u: SharedParam, u_b: SharedParam, hidden_state_in: np.Array = None, name: str = None): r""" Note that since the input dimension is determined at the first invocation of forward, this object does not yet know the input dimension and hecne cannot be initialized. :param x_node: source of x (input) value :param prev_rnn_node: used to get the previous state :param w: shared weight for X transformation :param w_b: shared bias for X :param u: shared weight for hidden state :param u_b: shared bias for hidden state :param hidden_state_in: must be specified if this is the first cell in a sequence :param name: easy to track name. This is appended by an ID to make sure names are unique """ MComputeNode.__init__(self, name, is_trainable=False) if prev_rnn_node is None: # this is the first node self._add_upstream_nodes([x_node]) if hidden_state_in is None: raise Exception("No initial hidden state provided") self.hidden_state_in = hidden_state_in else: self._add_upstream_nodes([x_node, prev_rnn_node]) self.hidden_state_in = hidden_state_in self.x_node = x_node self.prev_rnn_node = prev_rnn_node self.hidden_state_out = None self.W: SharedParam = w self.U: SharedParam = u self.Wb: SharedParam = w_b self.Ub: SharedParam = u_b self.output_shape = self.W.shape() self.hidden_shape = self.U.shape()
def __init__(self, prev_node: MComputeNode, output_dim: int, state_dim: int, output_all_sequences: bool = False, name: str = None): """ :param prev_node: A non RNN previous node. This will be changed soon to make it more flexible :param output_dim: dimension of "Y" :param state_dim: dimension of "H", the hidden state :param output_all_sequences: Only False is supported at present. :param name: """ MComputeNode.__init__(self, name=name, is_trainable=True) self.input_node = prev_node self._add_upstream_nodes([prev_node]) self.output_dim = output_dim self.state_dim = state_dim self.output_all_sequences = output_all_sequences self.weights_initialized = False self.initial_state = np.zeros((self.state_dim, 1))
def __init__(self, upstream_node, name=None): MComputeNode.__init__(self, name, False) self.input_node = upstream_node self._add_upstream_nodes([upstream_node])
def __init__(self, time_idx, input_value): MComputeNode.__init__(self, str(time_idx), is_trainable=False) self.node_value_ref = input_value self.time_index = time_idx self.node_value = self.node_value_ref[:, :, self.time_index]