def ctc_lambda_func(args, x): """ Create cost function (CTC) """ y_pred, labels, input_length, label_length = x return K.ctc_batch_cost(labels, y_pred, input_length, label_length)
def ctc_loss_v2(labels, y_pred): ''' Arguments: labels: arrays with shape [batch_size, time_steps] Each time step is an interger, y_pred: arrays with shape [batch_size, time_steps, num_of_class] Each time step is a numpy array with length of num_of_class Return: loss: single float number # ex: 0.12312 ''' def caculate_y_pred_lengths(y_pred): x = tf.shape(y_pred)[1] x = tf.tile([x], tf.shape(y_pred)[:1]) x = tf.reshape(tf.squeeze(x), [-1, 1]) x = tf.identity(x, 'y_pred_length') return x def caculate_label_lengths(labels, padding_value=-1): x = labels x = tf.logical_not(tf.equal(x, padding_value)) x = tf.cast(x, tf.int32) x = tf.reduce_sum(x, -1) x = tf.reshape(x, [-1, 1]) x = tf.identity(x, 'label_length') return x labels = tf.identity(labels, 'labels') y_pred = tf.identity(y_pred, 'y_preds') input_length = caculate_y_pred_lengths(y_pred) label_length = caculate_label_lengths(labels) # for x in [labels, y_pred, input_length, label_length]: print(x.name, x.shape) return K.ctc_batch_cost(labels, y_pred, input_length, label_length)
def ctc_loss(y_true, y_pred): """ Runs CTC Loss Algorithm on each batch element :param y_true: tensor (samples, max_string_length) containing the truth labels. :param y_pred: tensor (samples, time_steps, num_categories) containing the prediction, or output of the softmax. * caution input_length : tensor (samples, 1) containing the sequence length for each batch item in y_pred label_length : tensor (samples, 1) containing the sequence length for each batch item in y_true y_true는 [3,7,12,1,2,-1,-1,-1,-1] 와 같은 형태로 구성되어 있음. -1은 Blank를 의미 처음 등장하는 -1의 인덱스가 y_true의 sequnece length와 동일 y_pred의 총 width와 input_length는 동일 """ # Get the Length of Prediction shape = tf.shape(y_pred) batch_size = shape[0] max_length = shape[1, None, None] input_length = tf.tile(max_length, [batch_size, 1]) # Get the Length of Input label_length = tf.argmin(y_true, axis=-1)[:, None] return K.ctc_batch_cost(y_true, y_pred, input_length, label_length)
def focal_ctc_lambda_func(args): alpha = 0.75 gamma = 0.5 labels, y_pred, input_length, label_length = args ctc_loss = K.ctc_batch_cost(labels, y_pred, input_length, label_length) p = tf.exp(-ctc_loss) focal_ctc_loss = alpha * tf.pow((1 - p), gamma) * ctc_loss return focal_ctc_loss
def ctc_loss(labels, y_pred): ''' Arguments: labels: arrays with shape [batch_size, time_steps] Each time step is an interger, y_pred: arrays with shape [batch_size, time_steps, num_of_class] Each time step is a numpy array with length of num_of_class Return: loss: single float number # ex: 0.12312 ''' def caculate_y_pred_lengths(y_pred): x = tf.shape(y_pred)[1] x = tf.tile([x], tf.shape(y_pred)[:1]) return tf.reshape(tf.squeeze(x), [-1, 1]) def caculate_label_lengths(labels, padding_value=-1): i0 = tf.constant(0) m0 = tf.constant([1], shape=[1,1]) c = lambda i, m: i < tf.shape(labels)[0] def b(i, m): label_i = labels[i] invalid_indexes = tf.reshape(tf.where(tf.equal(label_i, padding_value)), [-1]) l = tf.shape(invalid_indexes)[0] li = tf.cond(tf.equal(l, 0), lambda: tf.shape(label_i)[0], lambda: tf.cast(invalid_indexes[0], tf.int32) ) li = tf.reshape(li, [1,1]) m = tf.concat([m, li], axis=0) m = tf.reshape(m, [-1, 1]) return [i+1, m] out_loop = tf.while_loop( c, b, loop_vars=[i0, m0], shape_invariants=[i0.get_shape(), tf.TensorShape([None, 1])]) out = out_loop[1][1:] out = tf.cast(out, tf.int32) return out labels = tf.concat([labels,tf.ones(shape=[tf.shape(labels)[0], 1])*-1], axis=-1) input_length = caculate_y_pred_lengths(y_pred) label_length = caculate_label_lengths(labels) label_length = tf.reshape(label_length, [-1, 1]) return K.ctc_batch_cost(labels, y_pred, input_length, label_length)
def ctc_lambda_func(args): y_pred, labels, input_length, label_length = args # the 2 is critical here since the first couple outputs of the RNN # tend to be garbage: y_pred = y_pred[:, 2:, :] return K.ctc_batch_cost(labels, y_pred, input_length, label_length)
def ctc_lambda(args): labels, y_pred, input_length, label_length = args y_pred = y_pred[:, :, :] return K.ctc_batch_cost(labels, y_pred, input_length, label_length)
def ctc_lambda_func(args): iy_pred, ilabels, iinput_length, ilabel_length = args # the 2 is critical here since the first couple outputs of the RNN # tend to be garbage: iy_pred = iy_pred[:, 2:, :] # no such influence return K.ctc_batch_cost(ilabels, iy_pred, iinput_length, ilabel_length)
def ctc_lambda_func(args): y_pred, labels, input_length, label_length = args y_pred = y_pred return K.ctc_batch_cost(labels, y_pred, input_length, label_length)