Python round Examples

Example #1

def running_precision(y_true, y_pred):
    TP = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    TP_FP = K.sum(K.round(K.clip(y_pred, 0, 1)))
    precision = TP / (TP_FP + K.epsilon())
    return precision

Example #2

def dice_coef_clipped(y_true, y_pred, smooth=1.0):
    y_true_f = K.flatten(K.round(y_true))
    y_pred_f = K.flatten(K.round(y_pred))
    intersection = K.sum(y_true_f * y_pred_f)
    return 100. * (2. * intersection + smooth) / (K.sum(y_true_f) +
                                                  K.sum(y_pred_f) + smooth)

Example #3

def precision_m(y_true, y_pred):
    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
    precision = true_positives / (predicted_positives + K.epsilon())
    return precision

Example #4

File: losses.py Project: vietanhdev/tf-blazepose

def tp(y_true, y_pred):
    smooth = 1
    y_pred_pos = K.round(K.clip(y_pred, 0, 1))
    y_pos = K.round(K.clip(y_true, 0, 1))
    tp = (K.sum(y_pos * y_pred_pos) + smooth) / (K.sum(y_pos) + smooth)
    return tp

Example #5

File: Implement_F1score.py Project: AhmedYounes94/usef1ascallback

 def recall_m(y_true, y_pred):
     TP = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
     Positives = K.sum(K.round(K.clip(y_true, 0, 1)))
     
     recall = TP / (Positives+K.epsilon())    
     return recall 

Example #6

File: model.py Project: HunterHeidy/DDICPI-

 def reverse_sequence(self, x, mask):
     """这里的mask.shape是[batch_size, seq_len, 1]
     """
     seq_len = K.round(K.sum(mask, 1)[:, 0])
     seq_len = K.cast(seq_len, 'int32')
     return tf.reverse_sequence(x, seq_len, seq_dim=1)

Example #7

File: algorithms.py Project: jtuoa/time-series

def specificity(y_true, y_pred): #TN/N (recall) 1=good
	true_negatives = K.sum(K.round(K.clip((1-y_true) * (1-y_pred), 0, 1)))
	possible_negatives = K.sum(K.round(K.clip(1-y_true, 0, 1)))
	return true_negatives / (possible_negatives + K.epsilon())

Example #8

File: losses.py Project: andreamatranga/building-damage

def recall(y_true, y_pred):
    true_positives_computed = true_positives(y_true, y_pred)
    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
    return true_positives_computed / (possible_positives + K.epsilon())

Example #9

File: losses.py Project: andreamatranga/building-damage

def precision(y_true, y_pred):
    true_positives_computed = true_positives(y_true, y_pred)
    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
    precision = true_positives_computed / (predicted_positives + K.epsilon())
    return precision

Example #10

File: losses.py Project: andreamatranga/building-damage

def true_negatives(y_true, y_pred):
    y_pred_neg = 1 - K.round(y_pred)
    y_neg = 1 - y_true
    return K.sum(y_neg * y_pred_neg)

Example #11

File: losses.py Project: andreamatranga/building-damage

def false_negatives(y_true, y_pred):
    y_pred_neg = 1 - K.round(y_pred)
    return K.sum(y_true * y_pred_neg)

Example #12

File: losses.py Project: andreamatranga/building-damage

def true_positives(y_true, y_pred):
    return K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))

Example #13

 def recall(y_true, y_pred):
     true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))  # mistake: y_pred of 0.3 is also considered 1
     possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
     recall = true_positives / (possible_positives + K.epsilon())
     return recall

Example #14

def f1_macro(y_true, y_pred):
    return tf.py_function(f1_sklean_mapping_macro, (y_true, K.round(y_pred)),
                          tf.double)

Example #15

File: modul.py Project: fadlytanjung/Prediction-DBD-case-with-ANN

 def soft_acc(self, y_true, y_pred):
     return K.mean(K.equal(K.round(y_true), K.round(y_pred)))

Example #16

File: R-CNN.py Project: ColinGreeley/Digital_Pathology

 def accuracy(self, y_true, y_pred):
     return K.mean(K.equal(K.round(y_true), K.round(y_pred)))

Example #17

 def soft_acc(self, y_true, y_pred):
     return K.mean(K.equal(K.round(y_true), K.round(y_pred)))
 
     '''pembuatan model'''

Example #18

File: DCGAN.py Project: Bengya/celeba-gan

def threshold_binary_accuracy(y_true, y_pred):
    return K.mean(K.equal(K.round(y_true), K.round(y_pred)), axis=-1)

Example #19

File: algorithms.py Project: jtuoa/time-series

def sensitivity(y_true, y_pred): #TP/P 1=good
	true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
	possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
	return true_positives / (possible_positives + K.epsilon())

Example #20

def round_through(x):
    rounded = K.round(x)
    return x + K.stop_gradient(rounded - x)

Example #21

File: algorithms.py Project: jtuoa/time-series

def precision(y_true, y_pred): #TP/TP+FP 1=good
	true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
	predicted_positives = K.sum(K.round(K.clip(y_pred,0, 1)))
	return true_positives / (predicted_positives + K.epsilon())

Example #22

 def recall(y_true, y_pred):
     tp = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
     rec = tp / (K.sum(K.round(K.clip(y_true, 0, 1))) + K.epsilon())
     return rec

Example #23

def true_positive_rate(y_true, y_pred):
    return K.sum(
        K.flatten(y_true) * K.flatten(K.round(y_pred))) / K.sum(y_true)

Example #24

 def precision(y_true, y_pred):
     tp = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
     prec = tp / (K.sum(K.round(K.clip(y_pred, 0, 1))) + K.epsilon())
     return prec

Example #25

File: Implement_F1score.py Project: AhmedYounes94/usef1ascallback

 def precision_m(y_true, y_pred):
     TP = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
     Pred_Positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
 
     precision = TP / (Pred_Positives+K.epsilon())
     return precision 

Example #26

File: evaluate.py Project: TeamEpochGithub/Cornell_bircall_identification

    # switch here
    generator = test_generator

    print("Dataloader done, time (s):", time.time() - start)
    print("Evaluating:")

    prediction = model.predict(generator)

    count = 0
    for i, p in enumerate(prediction):
        labels = generator[i // bsize][1][
            i % bsize]  # select batch, select labels, select sample
        label_idx = np.where(labels)[0]

        p *= confidence_boost
        count += K.sum(K.round(K.clip(p, 0, 1)))
        predicted_positives = K.round(K.clip(p, 0, 1)).numpy().astype(np.int)
        idx, = np.where(predicted_positives)
        predicted_birds = [birdcodes.inverted_bird_code[m] for m in idx]

        print("prediciton", i, predicted_birds, "prob", p[idx], "label",
              [birdcodes.inverted_bird_code[x] for x in label_idx])

    print("Number of predicted positives", count.numpy())

    results = model.evaluate(generator)
    results = {out: results[i] for i, out in enumerate(model.metrics_names)}
    print("EVALUATION:")
    padding = max(map(len, results))
    for k, v in results.items():
        print(f"{k:{padding}s}: {v}")

Example #27

File: binary_ops.py Project: abhishekbalu/Embedded-systems-and-machine-learning

def round_through(x):
    '''Element-wise rounding to the closest integer with full gradient propagation.
    A trick from [Sergey Ioffe](http://stackoverflow.com/a/36480182)
    '''
    rounded = K.round(x)
    return x + K.stop_gradient(rounded - x)

Example #28

File: evaluate.py Project: TeamEpochGithub/Cornell_bircall_identification

def recall_m(y_true, y_pred):
    y_pred *= confidence_boost
    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
    recall = true_positives / (possible_positives + K.epsilon())
    return recall

Example #29

    def recall(y_true, y_pred):

        true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
        possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
        recall = true_positives / (possible_positives + K.epsilon())
        return recall

Example #30

def running_recall(y_true, y_pred):
    TP = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    TP_FN = K.sum(K.round(K.clip(y_true, 0, 1)))
    recall = TP / (TP_FN + K.epsilon())
    return recall