精华内容
下载资源
问答
  • keras 自定义 metrics

    千次阅读 2018-11-26 14:36:00
    自定义 Metricskeras 中操作的均为 Tensor 对象,因此,需要定义操作 Tensor 的函数来操作所有输出结果,定义好函数之后,直接将其放在 model.compile 函数 metrics 中即可生效: def precision(y_true, y_pred)...

    自定义 Metrics

    keras 中操作的均为 Tensor 对象,因此,需要定义操作 Tensor 的函数来操作所有输出结果,定义好函数之后,直接将其放在 model.compile 函数 metrics 中即可生效:

    def precision(y_true, y_pred):
        # Calculates the precision
        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
    
    
    def recall(y_true, y_pred):
        # Calculates the recall
        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
    
    def fbeta_score(y_true, y_pred, beta=1):
        # Calculates the F score, the weighted harmonic mean of precision and recall.
    
        if beta < 0:
            raise ValueError('The lowest choosable beta is zero (only precision).')
            
        # If there are no true positives, fix the F score at 0 like sklearn.
        if K.sum(K.round(K.clip(y_true, 0, 1))) == 0:
            return 0
    
        p = precision(y_true, y_pred)
        r = recall(y_true, y_pred)
        bb = beta ** 2
        fbeta_score = (1 + bb) * (p * r) / (bb * p + r + K.epsilon())
        return fbeta_score
    
    def fmeasure(y_true, y_pred):
        # Calculates the f-measure, the harmonic mean of precision and recall.
        return fbeta_score(y_true, y_pred, beta=1)
    

    使用方法如下:

    model.compile( 
        optimizer=Adam(), 
        loss='binary_crossentropy',
        metrics = ['accuracy',  fmeasure, recall, precision])
    

    参考

    custom metrics for binary classification in Keras

    展开全文
  • keras自定义metrics

    千次阅读 2019-12-01 10:47:56
    在做回归问题的时候,发现keras中自带的acc不太好使,只能自定义一个acc myacc是我自己定义的,然后最后一句话就是我定义的myacc的等效计算 import numpy as np import matplotlib.pyplot as plt from sklearn....

    在做回归问题的时候,发现keras中自带的acc不太好使,只能自定义一个acc

    myacc是我自己定义的,然后最后一句话就是我定义的myacc的等效计算

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from keras.utils import to_categorical
    from keras.datasets import fashion_mnist
    from keras.layers import Input, Conv2D, MaxPooling2D, Dense, Flatten, Dropout,ZeroPadding2D, Activation, BatchNormalization
    from keras.optimizers import Adam
    from keras.models import Model
    from keras import backend as K
    import cv2
    import utils_paths  # 主要用于图像路径处理操作,具体代码参考最后的附录
    import random
    import os
    from sklearn.preprocessing import LabelBinarizer
    
    print("------开始读取训练集数据------")
    data = []
    labels = []
    
    # 拿到图像数据路径,方便后续读取
    imagePaths1 = sorted(list(utils_paths.list_images('./input')))
    imagePaths2 = sorted(list(utils_paths.list_images('./label')))
    random.seed(42)
    random.shuffle(imagePaths1)
    
    # 遍历读取数据
    for imagePath in imagePaths1:
        image = cv2.imread(imagePath,cv2.IMREAD_GRAYSCALE)
        #image = cv2.resize(image, (224, 224))###############################
        image = image.astype(np.int8) - 100
        data.append(image)
    
    for imagePath in imagePaths2:
        vector = cv2.imread(imagePath,cv2.IMREAD_GRAYSCALE)
        vector = vector.astype(np.int8) - 100
        labels.append(vector)
    
    # 归一化
    data = np.array(data, dtype="float") / 100
    labels = np.array(labels)/100
    
    data = data.reshape(data.shape[0],64,64,1)
    labels = labels.reshape(labels.shape[0],64)
    
    # 切分数据集
    (x_train, x_validate, y_train, y_validate) = train_test_split(data, labels, test_size=0.5, random_state=42)
    print("x_train.shape:",x_train.shape)
    print("x_validate.shape:",x_validate.shape)
    print("y_train.shape:",y_train.shape)
    print("y_validate.shape:",y_validate.shape)
    
    
    print("------训练集数据读取完毕------")
    
    
    
    def simpleModel(input_shape):
        X_input = Input(shape=input_shape)
        X = ZeroPadding2D(padding=(1, 1))(X_input)
        X = Conv2D(8, kernel_size=(3, 3), strides=(1, 1))(X)
        X = BatchNormalization(axis=3)(X)
        X = Activation('relu')(X)
        X = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')(X)
    
        X = ZeroPadding2D(padding=(1, 1))(X)
        X = Conv2D(16, kernel_size=(3, 3), strides=(1, 1))(X)
        X = BatchNormalization(axis=3)(X)
        X = Activation('relu')(X)
        X = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')(X)
    
        X = ZeroPadding2D(padding=(1, 1))(X)
        X = Conv2D(32, kernel_size=(3, 3), strides=(1, 1))(X)
        X = BatchNormalization(axis=3)(X)
        X = Activation('relu')(X)
        X = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')(X)
    
        # FC
        X = Flatten()(X)
        Y = Dense(64, activation='sigmoid')(X)
    
        model = Model(inputs=X_input, outputs=Y, name='simpleModel')
        return model
    
    
    def myacc(y_true, y_pred):
        SSR = K.mean(K.abs(y_pred-y_true),axis=-1)
        #return SSR
        return SSR <= 0.01
    
    model = simpleModel(input_shape=(64, 64, 1))
    
    model.compile(optimizer=Adam(lr=0.001), loss='mse', metrics=[myacc])
    model.fit(x_train, y_train, epochs=20, batch_size=256)
    model.save('./model.h5')
    model.save_weights('./weigths.h5')
    
    preds = model.evaluate(x_validate, y_validate)
    print("Loss = " + str(preds[0]))
    print("Test Accuracy = " + str(preds[1]))
    print(model.metrics_names)
    
    predict = model.predict(x_validate)
    # print(predict)
    # print(y_validate)
    #loss的计算如下,和上面输出的一致
    print(np.mean(np.mean(np.square(predict-y_validate),axis=-1),axis = 0))
    #myacc的计算如下,和上面输出的一致
    print(np.mean(np.mean(np.abs(predict-y_validate),axis=-1),axis = 0))
    
    

     

    展开全文
  • TensorFlow-Keras 2.自定义Loss与metrics

    千次阅读 2020-09-25 17:28:29
    sparse_categorical_crossentropy,metrics 针对稀疏多分类问题用到了 sparse_categorical_accuracy,这里 loss 和 metrics 也支持自己实现,只需要继承 keras.losses.Loss 和keras.metrics.Metric 类即可。...

    上一篇利用 keras 实现了最基本的手写数字识别模型,模型编译时loss用到了交叉熵 sparse_categorical_crossentropy,metrics 针对稀疏多分类问题用到了 sparse_categorical_accuracy,这里 loss 和 metrics 也支持自己实现,只需要继承 keras.losses.Loss 和keras.metrics.Metric 类即可。以下代码基于tensorflow 2.0 版本,Conda 3.7环境。

    Tips:

    首先导入需要用到的类,实现和上一篇Demo一样的模型结构,并且加载后面要用到的数据集。唯一的区别就是这里的模型还没有编译,没有指定对应的optimizer,loss,metrics。

    import numpy as np
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers
    
    # 模型结构化 后续可以多次调用
    def get_uncompiled_model():
        inputs = keras.Input(shape=(784,), name="digits")
        x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
        x = layers.Dense(64, activation="relu", name="dense_2")(x)
        outputs = layers.Dense(10, activation="softmax", name="predictions")(x)
        model = keras.Model(inputs=inputs, outputs=outputs)
        return model
    
    # 加载MNIST数据集
    (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
    print("训练集大小 {} 测试集大小 {}".format(len(x_train),len(x_test)))
    # Preprocess the data (these are NumPy arrays)
    x_train = x_train.reshape(60000, 784).astype("float32") / 255
    x_test = x_test.reshape(10000, 784).astype("float32") / 255
    
    y_train = y_train.astype("float32")
    y_test = y_test.astype("float32")
    
    # Reserve 10,000 samples for validation
    # 0-50000 训练 50000-60000 评估
    x_val = x_train[-10000:]
    y_val = y_train[-10000:]
    x_train = x_train[:-10000]
    y_train = y_train[:-10000]
    print("验证集大小 {} 验证集大小 {}".format(len(x_val),len(y_val)))

     

    一.自定义Loss

    神经网络在反向传播过程中,首先根据 y_pred 与 y_true 计算Loss值,然后根据 Loss 值计算梯度并将梯度应用到当前层的可训练参数中,更新参数后,再计算当前模型的评估指标,最终我们看到了输出的 Auc 等指标日志。这里第一步做的就是计算Loss,计算 loss 需要 预测值和真实值。在Keras下,可以直接实现损失函数在模型 compile 时传入,也可以实现Loss子类继承keras.losses.Loss。

    1.无参数实现自定义 Loss 函数

    实现最基本的 MSE 并在模型编译时传入

    def custom_mean_squared_error(y_true, y_pred):
        return tf.math.reduce_mean(tf.square(y_true - y_pred))
    
    model = get_uncompiled_model()
    model.compile(optimizer=demo.optimizers.Adam(), loss=custom_mean_squared_error)

    2.有参数实现自定义 Loss 函数

    上面的方法适合实现逻辑简单的 Loss ,如果需要更灵活的实现,就采用继承 Loss 子类的方式,这里需要重写下述方法:

    # __init__(self) :接受在损失函数调用期间传递的参数,这里可以加入更多自定义的参数,具体看自己的实现诉求

    # call(self, y_true, y_pred) :使用目标(y_true)和模型预测(y_pred)计算模型的损失 ,这里主要是实现 loss 的计算逻辑

    下面在 MSE 的基础上加入正则化因子实现 Loss:

    class CustomMSE(keras.losses.Loss):
        def __init__(self, regularization_factor=0.1, name="custom_mse"):
            super().__init__(name=name)
            self.regularization_factor = regularization_factor
    
        def call(self, y_true, y_pred):
            mse = tf.math.reduce_mean(tf.square(y_true - y_pred))
            reg = tf.math.reduce_mean(tf.square(0.5 - y_pred))
            return mse + reg * self.regularization_factor

     以上面 Loss 函数为例做一次测试:

    tips:这里官方文档给的one-hot方法有bug,one-hot函数无法对float32类型做编码,所以需要转换类型: 

    y_train_one_hot = tf.one_hot(y_train, depth=10)
    
    model = get_uncompiled_model()
    model.compile(optimizer=keras.optimizers.Adam(), loss=CustomMSE(0.4))
    
    # 官方文档中类型是tf.float32 onehot函数需要使用int32才可以,float32不可以 
    y_train_one_hot = tf.one_hot(tf.cast(y_train,dtype=tf.int32), depth=10)
    history = model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1,validation_data=(x_val, y_val),)
    
    history.history
       64/50000 [..............................] - ETA: 6:41 - loss: 0.1527
     1984/50000 [>.............................] - ETA: 13s - loss: 0.1384 
     3904/50000 [=>............................] - ETA: 7s - loss: 0.1262 
     5760/50000 [==>...........................] - ETA: 5s - loss: 0.1203
     7744/50000 [===>..........................] - ETA: 3s - loss: 0.1162
     9472/50000 [====>.........................] - ETA: 3s - loss: 0.1142
    11456/50000 [=====>........................] - ETA: 2s - loss: 0.1123
    13248/50000 [======>.......................] - ETA: 2s - loss: 0.1110
    15232/50000 [========>.....................] - ETA: 2s - loss: 0.1099
    16832/50000 [=========>....................] - ETA: 1s - loss: 0.1092
    18688/50000 [==========>...................] - ETA: 1s - loss: 0.1084
    20608/50000 [===========>..................] - ETA: 1s - loss: 0.1077
    22656/50000 [============>.................] - ETA: 1s - loss: 0.1071
    24640/50000 [=============>................] - ETA: 1s - loss: 0.1066
    26432/50000 [==============>...............] - ETA: 1s - loss: 0.1062
    28480/50000 [================>.............] - ETA: 0s - loss: 0.1057
    30400/50000 [=================>............] - ETA: 0s - loss: 0.1053
    32192/50000 [==================>...........] - ETA: 0s - loss: 0.1050
    34048/50000 [===================>..........] - ETA: 0s - loss: 0.1046
    36032/50000 [====================>.........] - ETA: 0s - loss: 0.1044
    38016/50000 [=====================>........] - ETA: 0s - loss: 0.1041
    40000/50000 [=======================>......] - ETA: 0s - loss: 0.1038
    41984/50000 [========================>.....] - ETA: 0s - loss: 0.1036
    43840/50000 [=========================>....] - ETA: 0s - loss: 0.1033
    45760/50000 [==========================>...] - ETA: 0s - loss: 0.1031
    47744/50000 [===========================>..] - ETA: 0s - loss: 0.1030
    49664/50000 [============================>.] - ETA: 0s - loss: 0.1028
    50000/50000 [==============================] - 2s 42us/sample - loss: 0.1027 - val_loss: 27.5961

    3.无参数实现有参数Loss

    还有一种 trick 的方法,可以不继承 keras.losses.Loss 实现带参数的自定义 Loss。还是以上面的 CustomMse 为例:

    def innerLoss(y_true,y_pred,regularrization):
        mse = tf.math.reduce_mean(tf.square(y_true - y_pred))
        reg = tf.math.reduce_mean(tf.square(0.5 - y_pred))
        return mse + reg * regularrization
    def CustomMSE(regularrization):
        def inner(y_true, y_pred):
            return innerLoss(y_true,y_pred,regularrization)
        return inner
    
    model = get_uncompiled_model()
            
    model.compile(optimizer=keras.optimizers.Adam(), loss=CustomMSE(0.4))

    这里 CustomMSE 采用了闭包的方式,将参数传给 innerLoss,再调用 inner 。注意,在不继承 keras.losses.Loss 实现自定义 Loss 时,损失函数只能有 y_true,y_pred 两个参数。

    比较一下前后两次 CustomMSE 的效果:

    # 继承 Loss 子类
    # loss: 0.1026 - val_loss: 27.5975
    # 不继承 Loss 子类
    # loss: 0.1027 - val_loss: 27.5959

    符合正常的波动,且两种方法都可以正常编译模型。

     

    二.自定义 Metrics

    除了自定义 Loss 外,Metrics 也可以自定义,类似于 AUC,RECALL 等等,这里需要继承 keras.metrics.Metric,并实现下述方法:

    # __init__(self) ,您将在其中创建度量标准的状态变量。

    # update_state(self, y_true, y_pred, sample_weight=None) ,它使用目标y_true和模型预测y_pred来更新状态变量。

    # result(self) ,它使用状态变量来计算最终结果。

    # reset_states(self) ,它重新初始化度量标准的状态。

    下面实现简单的0-1累加指标:

    class CategoricalTruePositives(keras.metrics.Metric):
        def __init__(self, name="categorical_true_positives", **kwargs):
            super(CategoricalTruePositives, self).__init__(name=name, **kwargs)
            self.true_positives = self.add_weight(name="ctp", initializer="zeros")
            # 也可以调整shape一次计算多个指标
            self.b = self.add_weight(name="b",initializer="random_uniform")
            print(self.b)
    
        # 通过y_true 与 y_pred 实现指标更新
        def update_state(self, y_true, y_pred, sample_weight=None):
            y_pred = tf.reshape(tf.argmax(y_pred, axis=1), shape=(-1, 1))
            values = tf.cast(y_true, "int32") == tf.cast(y_pred, "int32")
            values = tf.cast(values, "float32")
            if sample_weight is not None:
                sample_weight = tf.cast(sample_weight, "float32")
                values = tf.multiply(values, sample_weight)
            self.true_positives.assign_add(tf.reduce_sum(values))
    
        def result(self):
            return self.true_positives
    
        def reset_states(self):
            # The state of the metric will be reset at the start of each epoch.
            self.true_positives.assign(0.0)
    

    init 方法可以调用 add_weight 添加多个自已统计需要用到的变量,upstate 根据每轮的y _pred 与 p_true 更新指标的值,这里通过argMax函数找到分类器认为最大类的手写数字索引,与真实进行比较。

    预测正确:

    tf.Tensor(True, shape=(), dtype=bool)
    tf.Tensor(1.0, shape=(), dtype=float32)

    预测错误:

    tf.Tensor(False, shape=(), dtype=bool)
    tf.Tensor(0.0, shape=(), dtype=float32)

    可以简单理解为预测正确 +1 分,预测错不得分,所以随着epoch增加,如果模型越来越好,则该指标越来越大就对。下面测试一下:

    model = get_uncompiled_model()
    model.compile(
        optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
        loss=keras.losses.SparseCategoricalCrossentropy(),
        metrics=[CategoricalTruePositives()],
    )
    model.fit(x_train, y_train, batch_size=64, epochs=5,validation_split=0.2,)

    这里多余的就不打出来了,可以看到自定义的指标是一直增加的,和上面说的情况相符合。 

    Epoch 1/5
    loss: 0.3770 - categorical_true_positives: 35751.0000 - val_loss: 0.2375 - val_categorical_true_positives: 9274.0000
    Epoch 2/5
    loss: 0.1814 - categorical_true_positives: 37838.0000 - val_loss: 0.1873 - val_categorical_true_positives: 9440.0000
    Epoch 3/5
    loss: 0.1814 - categorical_true_positives: 37838.0000 - val_loss: 0.1873 - val_categorical_true_positives: 9440.0000
    Epoch 4/5
    loss: 0.1326 - categorical_true_positives: 38437.0000 - val_loss: 0.1658 - val_categorical_true_positives: 9506.0000
    Epoch 5/5
    loss: 0.1040 - categorical_true_positives: 38730.0000 - val_loss: 0.1454 - val_categorical_true_positives: 9587.0000

    最基本的自定义Loss,Metrics就这些了,当然不仅仅限制于model,Layer层也可以添加损失与指标,获取更多细节可以查看tensorflow官方API

    展开全文
  • 浅谈keras自定义二分类任务评价指标metrics的方法以及代码更多python视频教程请到菜鸟教程https://www.piaodoo.com/ 对于二分类任务,keras现有的评价指标只有binary_accuracy,即二分类准确率,但是评估...

    浅谈keras中自定义二分类任务评价指标metrics的方法以及代码

    更多python视频教程请到菜鸟教程https://www.piaodoo.com/

    对于二分类任务,keras现有的评价指标只有binary_accuracy,即二分类准确率,但是评估模型的性能有时需要一些其他的评价指标,例如精确率,召回率,F1-score等等,因此需要使用keras提供的自定义评价函数功能构建出针对二分类任务的各类评价指标。

    keras提供的自定义评价函数功能需要以如下两个张量作为输入,并返回一个张量作为输出。

    y_true:数据集真实值组成的一阶张量。

    y_pred:数据集输出值组成的一阶张量。

    tf.round()可对张量四舍五入,因此tf.round(y_pred)即是预测值张量。

    1-tf.round(y_pred)即是预测值张量取反。

    1-y_true即是真实值张量取反。

    tf.reduce_sum()可对张量求和。

    由此可以根据定义构建出四个基础指标TP、TN、FP、FN,然后进一步构建出进阶指标precision、recall、F1score,最后在编译阶段引用上述自定义评价指标即可。

    keras中自定义二分类任务常用评价指标及其引用的代码如下

    import tensorflow as tf
    

    #精确率评价指标
    def metric_precision(y_true,y_pred):
    TP=tf.reduce_sum(y_truetf.round(y_pred))
    TN=tf.reduce_sum((1-y_true)
    (1-tf.round(y_pred)))
    FP=tf.reduce_sum((1-y_true)tf.round(y_pred))
    FN=tf.reduce_sum(y_true
    (1-tf.round(y_pred)))
    precision=TP/(TP+FP)
    return precision

    #召回率评价指标
    def metric_recall(y_true,y_pred):
    TP=tf.reduce_sum(y_truetf.round(y_pred))
    TN=tf.reduce_sum((1-y_true)
    (1-tf.round(y_pred)))
    FP=tf.reduce_sum((1-y_true)tf.round(y_pred))
    FN=tf.reduce_sum(y_true
    (1-tf.round(y_pred)))
    recall=TP/(TP+FN)
    return recall

    #F1-score评价指标
    def metric_F1score(y_true,y_pred):
    TP=tf.reduce_sum(y_truetf.round(y_pred))
    TN=tf.reduce_sum((1-y_true)
    (1-tf.round(y_pred)))
    FP=tf.reduce_sum((1-y_true)tf.round(y_pred))
    FN=tf.reduce_sum(y_true
    (1-tf.round(y_pred)))
    precision=TP/(TP+FP)
    recall=TP/(TP+FN)
    F1score=2precisionrecall/(precision+recall)
    return F1score

    #编译阶段引用自定义评价指标示例
    model.compile(optimizer=‘adam’,
    loss=‘binary_crossentropy’,
    metrics=[‘accuracy’,
    metric_precision,
    metric_recall,
    metric_F1score])

    补充知识:keras sklearn下两分类/多分类的技术杂谈(交叉验证和评价指标)

    一.前言

    这篇博客是为了记录论文补充实验中所遇到的问题,以及解决方法,主要以程序的形式呈现。

    二.对象

    深度学习框架:keras

    研究对象:两分类/多分类

    三.技术杂谈

    1.K-FOLD交叉验证

    1.概念

    对一个模型进行K次训练,每次训练将整个数据集分为随机的K份,K-1作为训练集,剩余的1份作为验证集,每次训练结束将验证集上的性能指标保存下来,最后对K个结果进行平均得到最终的模型性能指标。

    2.优缺点

    优点:模型评估更加鲁棒

    缺点:训练时间加大

    3.代码

    ① sklearn与keras独立使用

    from sklearn.model_selection import StratifiedKFold
    import numpy
    

    seed = 7 # 随机种子
    numpy.random.seed(seed) # 生成固定的随机数
    num_k = 5 # 多少折

    整个数据集(自己定义)

    X =
    Y =

    kfold = StratifiedKFold(n_splits=num_k, shuffle=True, random_state=seed) # 分层K折,保证类别比例一致

    cvscores = []
    for train, test in kfold.split(X, Y):

    # 可以用sequential或者function的方式建模(自己定义)
    model = 
    

    model.compile() # 自定义

    # 模型训练
    

    model.fit(X[train], Y[train], epochs=150, batch_size=10, verbose=0)

    模型测试

    scores = model.evaluate(X[test], Y[test], verbose=0)

    print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100)) # 打印出验证集准确率

    cvscores.append(scores[1] * 100)

    print("%.2f%% (+/- %.2f%%)" % (numpy.mean(cvscores), numpy.std(cvscores))) # 输出k-fold的模型平均和标准差结果

    ② sklearn与keras结合使用

    from keras.wrappers.scikit_learn import KerasClassifier # 使用keras下的sklearn API
    from sklearn.cross_validation import StratifiedKFold, cross_val_score
    import numpy as np
    

    seed = 7 # 随机种子
    numpy.random.seed(seed) # 生成固定的随机数
    num_k = 5 # 多少折

    整个数据集(自己定义)

    X =
    Y =

    创建模型

    def model():

    可以用sequential或者function的方式建模(自己定义)

    model = 
    return model 
    

    model = KerasClassifier(build_fn=model, epochs=150, batch_size=10)
    kfold = StratifiedKFold(Y, n_folds=num_k, shuffle=True, random_state=seed)
    results = cross_val_score(model, X, Y, cv=kfold)
    print(np.average(results)) # 输出k-fold的模型平均结果

    补充:引入keras的callbacks

    只需要在①②中的model.fit中加入一个arg:callbacks=[keras.callbacks.ModelCheckpoint()] # 这样可以保存下模型的权重,当然了你也可以使用callbacks.TensorBoard保存下训练过程

    2.二分类/多分类评价指标

    1.概念

    二分类就是说,一个目标的标签只有两种之一(例如:0或1,对应的one-hot标签为[1,0]或[0,1])。对于这种问题,一般可以采用softmax或者logistic回归来完成,分别采用cross-entropy和mse损失函数来进行网络训练,分别输出概率分布和单个的sigmoid预测值(0,1)。

    多分类就是说,一个目标的标签是几种之一(如:0,1,2…)

    2.评价指标

    主要包含了:准确率(accuracy),错误率(error rate),精确率(precision),召回率(recall)= 真阳率(TPR)= 灵敏度(sensitivity),F1-measure(包含了micro和macro两种),假阳率(FPR),特异度(specificity),ROC(receiver operation characteristic curve)(包含了micro和macro两种),AUC(area under curve),P-R曲线(precision-recall),混淆矩阵

    ① 准确率和错误率

    accuracy = (TP+TN)/ (P+N)或者accuracy = (TP+TN)/ (T+F)

    error rate = (FP+FN) / (P+N)或者(FP+FN) / (T+F)

    accuracy = 1 - error rate

    可见:准确率、错误率是对分类器在整体数据上的评价指标。

    ② 精确率

    precision=TP /(TP+FP)

    可见:精确率是对分类器在预测为阳性的数据上的评价指标。

    ③ 召回率/真阳率/灵敏度

    recall = TPR = sensitivity = TP/(TP+FN)

    可见:召回率/真阳率/灵敏度是对分类器在整个阳性数据上的评价指标。

    ④ F1-measure

    F1-measure = 2 * (recall * precision / (recall + precision))

    包含两种:micro和macro(对于多类别分类问题,注意区别于多标签分类问题)

    1)micro

    计算出所有类别总的precision和recall,然后计算F1-measure

    2)macro

    计算出每一个类的precison和recall后计算F1-measure,最后将F1-measure平均

    可见:F1-measure是对两个矛盾指标precision和recall的一种调和。

    ⑤ 假阳率

    FPR=FP / (FP+TN)

    可见:假阳率是对分类器在整个阴性数据上的评价指标,针对的是假阳。

    ⑥ 特异度

    specificity = 1- FPR

    可见:特异度是对分类器在整个阴性数据上的评价指标,针对的是真阴。

    ⑦ ROC曲线和AUC

    作用:灵敏度与特异度的综合指标

    横坐标:FPR/1-specificity

    纵坐标:TPR/sensitivity/recall

    AUC是ROC右下角的面积,越大,表示分类器的性能越好

    包含两种:micro和macro(对于多类别分类问题,注意区别于多标签分类问题)

    假设一共有M个样本,N个类别。预测出来的概率矩阵P(M,N),标签矩阵L (M,N)

    1)micro

    根据P和L中的每一列(对整个数据集而言),计算出各阈值下的TPR和FPR,总共可以得到N组数据,分别画出N个ROC曲线,最后取平均

    2)macro

    将P和L按行展开,然后转置为两列,最后画出一个ROC曲线

    ⑧ P-R曲线

    横轴:recall

    纵轴:precision

    评判:1)直观看,P-R包围的面积越大越好,P=R的点越大越好;2)通过F1-measure来看

    比较ROC和P-R: 当样本中的正、负比例不平衡的时候,ROC曲线基本保持不变,而P-R曲线变化很大,原因如下:

    当负样本的比例增大时,在召回率一定的情况下,那么表现较差的模型必然会召回更多的负样本,TP降低,FP迅速增加(对于性能差的分类器而言),precision就会降低,所以P-R曲线包围的面积会变小。

    ⑨ 混淆矩阵

    行表示的是样本中的一种真类别被预测的结果,列表示的是一种被预测的标签所对应的真类别。

    3.代码

    注意:以下的代码是合在一起写的,有注释。

    from sklearn import datasets
    import numpy as np
    from sklearn.preprocessing import label_binarize
    from sklearn.linear_model import LogisticRegression
    from sklearn.metrics import confusion_matrix, precision_score, accuracy_score,recall_score, f1_score,roc_auc_score, precision_recall_fscore_support, roc_curve, classification_report
    import matplotlib.pyplot as plt
    

    iris = datasets.load_iris()
    x, y = iris.data, iris.target
    print(“label:”, y)
    n_class = len(set(iris.target))
    y_one_hot = label_binarize(y, np.arange(n_class))

    alpha = np.logspace(-2, 2, 20) #设置超参数范围

    model = LogisticRegressionCV(Cs = alpha, cv = 3, penalty = ‘l2’) #使用L2正则化

    model = LogisticRegression() # 内置了最大迭代次数了,可修改
    model.fit(x, y)
    y_score = model.predict(x) # 输出的是整数标签
    mean_accuracy = model.score(x, y)
    print("mean_accuracy: ", mean_accuracy)
    print(“predict label:”, y_score)
    print(y_score==y)
    print(y_score.shape)
    y_score_pro = model.predict_proba(x) # 输出概率
    print(y_score_pro)
    print(y_score_pro.shape)
    y_score_one_hot = label_binarize(y_score, np.arange(n_class)) # 这个函数的输入必须是整数的标签哦
    print(y_score_one_hot.shape)

    obj1 = confusion_matrix(y, y_score) # 注意输入必须是整数型的,shape=(n_samples, )
    print(‘confusion_matrix\n’, obj1)

    print(y)
    print(‘accuracy:{}’.format(accuracy_score(y, y_score))) # 不存在average
    print(‘precision:{}’.format(precision_score(y, y_score,average=‘micro’)))
    print(‘recall:{}’.format(recall_score(y, y_score,average=‘micro’)))
    print(‘f1-score:{}’.format(f1_score(y, y_score,average=‘micro’)))
    print(‘f1-score-for-each-class:{}’.format(precision_recall_fscore_support(y, y_score))) # for macro

    print(‘AUC y_pred = one-hot:{}\n’.format(roc_auc_score(y_one_hot, y_score_one_hot,average=‘micro’))) # 对于multi-class输入必须是proba,所以这种是错误的

    AUC值

    auc = roc_auc_score(y_one_hot, y_score_pro,average=‘micro’) # 使用micro,会计算n_classes个roc曲线,再取平均
    print(“AUC y_pred = proba:”, auc)

    画ROC曲线

    print(“one-hot label ravelled shape:”, y_one_hot.ravel().shape)
    fpr, tpr, thresholds = roc_curve(y_one_hot.ravel(),y_score_pro.ravel()) # ravel()表示平铺开来,因为输入的shape必须是(n_samples,)
    print("threshold: ", thresholds)
    plt.plot(fpr, tpr, linewidth = 2,label=‘AUC=%.3f’ % auc)
    plt.plot([0,1],[0,1], ‘k–’) # 画一条y=x的直线,线条的颜色和类型
    plt.axis([0,1.0,0,1.0]) # 限制坐标范围
    plt.xlabel(‘False Postivie Rate’)
    plt.ylabel(‘True Positive Rate’)
    plt.legend()
    plt.show()

    p-r曲线针对的是二分类,这里就不描述了

    ans = classification_report(y, y_score,digits=5) # 小数点后保留5位有效数字
    print(ans)

    以上这篇浅谈keras中自定义二分类任务评价指标metrics的方法以及代码就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多

    茂名论坛https://www.hnthzk.com/

    化州橘红http://www.sfkyty.com/

    茂名论坛http://www.nrso.net/

    源码搜藏网http://www.cntkd.net/

    茂名市高级技工学校(茂名一技)http://www.szsyby.net/

    茂名一技https://www.mmbbu.com/

    展开全文
  • keras中,在model compile的时候可以通过设置metrics的方式确定预测指标,但是keras已经写好的函数中没有精确率和召回率的实现,因此需要自定义这两个指标,哪位大大能帮忙实现一下?拜谢!
  • 对于二分类任务,keras现有的评价指标只有binary_accuracy,即二分类准确率,但是评估模型的性能有时需要一些其他的评价指标,例如精确率,召回率,F1-score等等,因此需要使用keras提供的自定义评价函数功能构建出...
  • tf.keras提供了许多方便调用的API构建深度学习模型,但有些情况需要自定义层和模型,因此在这篇文章里,我们将着眼自定义模型,使用TensorFlow 2.X里的自定义方法为解决方案提供更多灵活性。 2 自定义层 2.1 创建...
  • Keras自定义模型

    2020-03-09 18:26:28
    tf.keras.Sequential 模型是层的简单堆叠,无法表示任意模型。 inputs = tf.keras.Input(shape=(32,)) # 构建一个输入张量 # 层layer的实例对象是callable的,他接受一个tensor,并返回一个处理之后的tensor x = ...
  • keras中实现自定义loss, 可以有两种方式,一种自定义 loss function, 例如: # 方式一 def vae_loss(x, x_decoded_mean): xent_loss = objectives.binary_crossentropy(x, x_decoded_mean) kl_loss = - 0.5 * ...
  • keras自定义函数时候,正常在模型里自己写好自定义的函数,然后在模型编译的那行代码里写上接口即可。如下所示,focal_loss和fbeta_score是我们自己定义的两个函数,在model.compile加入它们,metrics里‘accuracy’...
  • 目录可使用的评价函数binary_accuracycategorical_accuracysparse_categorical_accuracytop_k_categorical_accuracysparse_top_k_categorical_accuracy...from keras import metrics model.compile(loss='mean_square
  • finalmodel.compile(loss='mse',optimizer='adam',metrics=[r_square]) (上:y预测-y真,our model,下:y真平均-y真,baseline model)  使用baseline模型肯定会产生很多错误,我们自己的模型产生的...
  • Keras自定义数据集

    2020-04-23 00:38:34
    Keras学习过程中,使用的数据集都是keras.datasets.mnist.load_data(),直接使用处理好的数据集,想要尝试使用自己搜集的图片,却又不知道如何加载。查找其他人自定义数据集的方式,做一个记录。 链接: ...
  • tensorflow 自定义metrics

    2021-02-03 17:17:04
    tensoflow的自定义metrics类需要重定义下面3个方法: init 初始化类,主要包括注册权重变量,自定义类的名字 update_state 此方法是关键的一个方法,更新指标就在这个方法中实现 result 返回结果 其他的方法可以...
  • keras自定义loss的两个例子

    千次阅读 2019-09-01 21:25:27
    Lookahead和LazyOptimizer和AccumOptimizer...Keras实现两个优化器 用时间换取效果:Keras梯度累积优化器 AccumOptimizer keras inject#497 keras/optimizers.py lookahead用法: model.compile(optimizer=Adam(1e-3)...
  • keras自定义loss函数

    2020-05-19 20:33:53
    自定义loss函数很重要,在写rmse的时候,发现keras并没有,所以找了其他博客。其实也很简单,输入是真实值和预测值。 rmse: def rmse(y_true, y_pred): return K.sqrt(K.mean(K.square(y_pred - y_true), axis=-1)...
  • Keras自定义损失函数

    千次阅读 2018-11-16 12:29:42
    Keras内置损失函数都预定义在keras.metrics.losses中,以MSE为例,其预定义方法如下: def mean_squared_error(y_true, y_pred): return K.mean(K.square(y_pred - y_true), axis=-1) 我们可以仿照其写法,定义...
  • keras自定义评估函数

    热门讨论 2019-11-20 11:56:47
    原文:...import keras.backend as K #precision def P(y_true, y_pred): true_positives = K.sum(K.cast(K.greater(K.clip(y_true * y_pred, 0, 1), ...
  • Keras自定义Loss函数

    万次阅读 多人点赞 2018-01-13 12:00:09
    有时候我们需要根据自己所做的任务来自定义损失函数,虽然Keras是一个很高级的封装,自定义loss还是比较简单的。这里记录一下自定义loss的方法,一为助记、二为助人。 官方定义的损失函数 第一种方式:自定义一...
  • Advanced Keras — Constructing Complex Custom Losses and Metrics1. 背景2. 自定义loss函数3. 多参数loss/metric函数 翻译自:...
  • Tensorflow2自定义层和激活函数带参数的自定义激活函数带参数的自定义层使用 ...在网上搜了许多,都没找我想要的自定义方法,所以自己摸索着写了个,也...from tensorflow.python.keras.engine.base_layer import Layer f
  • keras自定义损失函数

    万次阅读 2018-05-24 14:46:58
    在tensorflow出来之前,Keras就已经几乎是当时最火的深度学习框架,以theano为后端,而如今Keras已经同时支持四种后端:theano、tensorflow、cntk、mxnet(前三种官方支持,mxnet还没整合到官方中),由此可见Keras...
  • keras自定义评价函数

    2021-10-14 06:57:19
    import keras.backend as K from keras import Sequential from keras.layers import Dense import numpy as np def getPrecision(y_true, y_pred): TP = K.sum(K.round(K.clip(y_true * y_pr...
  • # 自定义损失函数 def custom_loss(y_true, y_prd): # mean((y_prd-y_true)** 2) 均方差损失函数 return tf.reduce_mean(tf.square(y_prd - y_true)) # 模型的编译 设置损失函数 优化器 model.compile(loss=...
  • 然而keras中没有多标签分类绝对准确率的metrics,同时自己在做多标签分类的时候存在类别不平衡的问题,想使用focalloss平衡一下,这里是找到的可以用于多标签问题的focal_loss,下面两个都可以试试: #用于类别不...
  • keras自定义loss function的简单方法

    千次阅读 2019-07-08 09:24:39
    首先看一下Keras中我们常用到的目标函数(如mse,sae等)是如何定义的 from keras import backend as K def mean_squared_error(y_true, y_pred): return K.mean(K.square(y_pred - y_true), axis=-1) def...
  • 在Keras使用center-losss损失函数\Keras自定义损失函数

    千次阅读 热门讨论 2018-11-19 10:21:20
    在Keras使用center-losss损失函数\Keras自定义损失函数
  • 可以通过将 tf.keras.metrics.Metric 类子类化来轻松创建自定义指标。您将需要实现 4 个方法: __init__(self),您将在其中为指标创建状态变量。 update_state(self, y_true, y_pred, sample_weight=None),使用...
  • 1.自定义层 ...这是一个Keras2.0中,Keras 层的骨架(如果你用的是旧的版本,请更新到新版)。你只需要实现三个方法即可: build(input_shape): 这是你定义权重的地方。这个方法必须设self.built =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,041
精华内容 1,216
关键字:

keras自定义metrics