七、模型评估指标

news2024/11/17 0:47:11

当训练好模型之后，检测模型训练效果如何，评价指标有哪些？通过查阅相关资料，我将以这五个指标来对所训练的模型进行评估，下图是评价指标运行结果图。

在这里插入图片描述

一、混淆矩阵（Confusion Matrix）

解释：也就是个n维矩阵，n表示分类的类别数。
具体的表示如下(这里以二分类任务为例)：也就是图中的二维矩阵
在这里插入图片描述在这里插入图片描述
上述的所有指标都是建立在混淆矩阵的基础上进行计算的
我这里以织物毛球和纹理进行识别，毛球为Positive，纹理为Negative
这个二维矩阵有四个参数：

参数解释
True Positive模型预测识别为Positive，识别正确True；实际为Positive
False Negative模型预测识别为Negative，识别错误False；实际为Positive
False Positive模型预测识别为Positive，识别错误False；实际为Negative
True Negative模型预测识别为Negative，识别正确True；实际为Negative

这些值对测试图像中所有像素点进行分类统计

代码实现：

修改：SegmentationMetric(2)改成实际训练模型的分类数，我这个模型训练的是二分类任务
imgPredict和imgLabel 改成自己模型预测的图像和标签图像的路径
实际上，imgLabel为正确答案，依次遍历imgPredict中像素点，与正确答案进行对比，统计上述参数的个数，最后绘制成混淆矩阵。

import numpy as np
import cv2

class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）


    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix


    def genConfusionMatrix(self, imgPredict, imgLabel): 
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        return confusionMatrix


# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    = cv2.imread("../result/img.jpg")

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)

    metric = SegmentationMetric(2)  # 2表示有2个分类
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)

    print('ConfusionMatrix is :\n', ConfusionMatrix)

运行结果如下：在这里插入图片描述

二、像素准确率PA（Pixel Accuracy）

PA最后的输出是一个数值，因为是，无论多少类别的分类，都是跟标准标签进行对比，一致就是True，不一致就是False

PA，别的论文也称为准确率、Acc等，都指的是像素准确率
Accuracy = (TP + TN) / (TP + TN + FP + FN)，也就是对角线元素之和/总的元素之和
（99586+1150）/（99586+1108+556+1150）= 0.983750，这也对应了第一张图的显示结果

代码实现：

import numpy as np
import cv2

class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）


    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix


    def genConfusionMatrix(self, imgPredict, imgLabel):
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        return confusionMatrix


    def pixelAccuracy(self):
        acc = np.diag(self.confusionMatrix).sum() / self.confusionMatrix.sum()
        return acc

# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    imgLabel = cv2.imread("../result/img.jpg")

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)

    metric = SegmentationMetric(2)  # 2表示有2个分类
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)

    PixelAccuracy = metric.pixelAccuracy()

    print('PixelAccuracy is :\n', PixelAccuracy)

运行结果如下：
在这里插入图片描述

三、类别像素准确率CPA（Class Pixel Accuracy）

CPA与PA不同，PA是将整体区分True和False最后结果是一个数值
CPA则先将不同的类别进行划分，每个类别再分别与标签给定的正确答案进行对比统计，最后的个数是类别个数，有几个类别就是几个数值。

代码实现：

import numpy as np
import cv2

class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）


    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix


    def genConfusionMatrix(self, imgPredict, imgLabel):
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        return confusionMatrix

    def classPixelAccuracy(self):
        classAcc = np.diag(self.confusionMatrix) / self.confusionMatrix.sum(axis=1)
        return classAcc  # 返回的是一个列表值，如：[0.90, 0.80, 0.96]，表示类别1 2 3各类别的预测准确率

# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    imgLabel = cv2.imread("../result/img.jpg")

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)

    metric = SegmentationMetric(2)  # 2表示有2个分类
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)

    cpa = metric.classPixelAccuracy()

    print('classPixelAccuracy is :\n', cpa)

因为是二分类任务，故分别显示这两个类别的PA值
运行效果如下：
在这里插入图片描述

四、类别平均像素准确率MPA（Mean class Pixel Accuracy）

也就是将所有的CPA加一块，求个平均值

代码实现：

import numpy as np
import cv2

class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）


    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix


    def genConfusionMatrix(self, imgPredict, imgLabel):
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        return confusionMatrix

    def classPixelAccuracy(self):
        classAcc = np.diag(self.confusionMatrix) / self.confusionMatrix.sum(axis=1)
        return classAcc  # 返回的是一个列表值，如：[0.90, 0.80, 0.96]，表示类别1 2 3各类别的预测准确率

    def meanPixelAccuracy(self):
        classAcc = self.classPixelAccuracy()
        meanAcc = np.nanmean(classAcc)  # np.nanmean 求平均值，nan表示遇到Nan类型，其值取为0
        return meanAcc  # 返回单个值，如：np.nanmean([0.90, 0.80, 0.96, nan, nan]) = (0.90 + 0.80 + 0.96） / 3 =  0.89

# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    imgLabel = cv2.imread("../result/img.jpg")

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)

    metric = SegmentationMetric(2)  # 2表示有2个分类
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)

    mpa = metric.meanPixelAccuracy()

    print('meanPixelAccuracy is :\n', mpa)

（0.98899637+0.67409144）/ 2 = 0.831543905
运行结果如下：
在这里插入图片描述

五、交并比IoU（Intersection Over Union）

通俗来说：将标签图像和模型预测出的图像重叠一下，分别取交集和并集，这里的交集和并集取得是统计像素点的个数
IoU是按不同类别分别进行求解的，几个类别就有几个IoU
IoU = 交集 / 并集
在这里插入图片描述

代码实现：

import numpy as np
import cv2

class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）


    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix


    def genConfusionMatrix(self, imgPredict, imgLabel):
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        return confusionMatrix


    def pixelAccuracy(self):
        acc = np.diag(self.confusionMatrix).sum() / self.confusionMatrix.sum()
        return acc
    

    def IntersectionOverUnion(self):
        # Intersection = TP Union = TP + FP + FN
        # IoU = TP / (TP + FP + FN)
        intersection = np.diag(self.confusionMatrix)  # 取对角元素的值，返回列表
        union = np.sum(self.confusionMatrix, axis=1) + np.sum(self.confusionMatrix, axis=0) - np.diag(
            self.confusionMatrix)  # axis = 1表示混淆矩阵行的值，返回列表； axis = 0表示取混淆矩阵列的值，返回列表
        IoU = intersection / union  # 返回列表，其值为各个类别的IoU
        return IoU
# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    imgLabel = cv2.imread("../result/img.jpg")

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)

    metric = SegmentationMetric(2)  # 2表示有2个分类
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)


    IoU = metric.IntersectionOverUnion()

    print('IntersectionOverUnion is :\n', IoU)

效果图如下：
在这里插入图片描述

六、平均交并比MIoU（Mean Intersection Over Union）

将不同类别的IoU求个平均数

代码实现：

import numpy as np
import cv2

class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）


    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix


    def genConfusionMatrix(self, imgPredict, imgLabel):
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        return confusionMatrix


    def pixelAccuracy(self):
        acc = np.diag(self.confusionMatrix).sum() / self.confusionMatrix.sum()
        return acc


    def IntersectionOverUnion(self):
        # Intersection = TP Union = TP + FP + FN
        # IoU = TP / (TP + FP + FN)
        intersection = np.diag(self.confusionMatrix)  # 取对角元素的值，返回列表
        union = np.sum(self.confusionMatrix, axis=1) + np.sum(self.confusionMatrix, axis=0) - np.diag(
            self.confusionMatrix)  # axis = 1表示混淆矩阵行的值，返回列表； axis = 0表示取混淆矩阵列的值，返回列表
        IoU = intersection / union  # 返回列表，其值为各个类别的IoU
        return IoU


    def meanIntersectionOverUnion(self):
        mIoU = np.nanmean(self.IntersectionOverUnion())  # 求各类别IoU的平均
        return mIoU
# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    imgLabel = cv2.imread("../result/img.jpg")

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)

    metric = SegmentationMetric(2)  # 2表示有2个分类
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)

    mIoU = metric.meanIntersectionOverUnion()

    print('meanIntersectionOverUnion is :\n', mIoU)

运行结果如下：
在这里插入图片描述

七、完整代码

import numpy as np
import cv2

__all__ = ['SegmentationMetric']

"""
confusionMetric  # 注意：此处横着代表预测值，竖着代表真实值
P\L     P    N
P      TP    FP
N      FN    TN
"""


class SegmentationMetric(object):
    def __init__(self, numClass):
        self.numClass = numClass
        self.confusionMatrix = np.zeros((self.numClass,) * 2)  # 混淆矩阵（空）

    def pixelAccuracy(self):
        # return all class overall pixel accuracy 正确的像素占总像素的比例
        #  PA = acc = (TP + TN) / (TP + TN + FP + TN)
        acc = np.diag(self.confusionMatrix).sum() / self.confusionMatrix.sum()
        return acc

    def classPixelAccuracy(self):
        # return each category pixel accuracy(A more accurate way to call it precision)
        # acc = (TP) / TP + FP
        classAcc = np.diag(self.confusionMatrix) / self.confusionMatrix.sum(axis=1)
        return classAcc  # 返回的是一个列表值，如：[0.90, 0.80, 0.96]，表示类别1 2 3各类别的预测准确率

    def meanPixelAccuracy(self):
        """
        Mean Pixel Accuracy(MPA，均像素精度)：是PA的一种简单提升，计算每个类内被正确分类像素数的比例，之后求所有类的平均。
        :return:
        """
        classAcc = self.classPixelAccuracy()
        meanAcc = np.nanmean(classAcc)  # np.nanmean 求平均值，nan表示遇到Nan类型，其值取为0
        return meanAcc  # 返回单个值，如：np.nanmean([0.90, 0.80, 0.96, nan, nan]) = (0.90 + 0.80 + 0.96） / 3 =  0.89

    def IntersectionOverUnion(self):
        # Intersection = TP Union = TP + FP + FN
        # IoU = TP / (TP + FP + FN)
        intersection = np.diag(self.confusionMatrix)  # 取对角元素的值，返回列表
        union = np.sum(self.confusionMatrix, axis=1) + np.sum(self.confusionMatrix, axis=0) - np.diag(
            self.confusionMatrix)  # axis = 1表示混淆矩阵行的值，返回列表； axis = 0表示取混淆矩阵列的值，返回列表
        IoU = intersection / union  # 返回列表，其值为各个类别的IoU
        return IoU

    def meanIntersectionOverUnion(self):
        mIoU = np.nanmean(self.IntersectionOverUnion())  # 求各类别IoU的平均
        return mIoU

    def genConfusionMatrix(self, imgPredict, imgLabel):  #
        """
        同FCN中score.py的fast_hist()函数,计算混淆矩阵
        :param imgPredict:
        :param imgLabel:
        :return: 混淆矩阵
        """
        # remove classes from unlabeled pixels in gt image and predict
        mask = (imgLabel >= 0) & (imgLabel < self.numClass)
        label = self.numClass * imgLabel[mask] + imgPredict[mask]
        count = np.bincount(label, minlength=self.numClass ** 2)
        confusionMatrix = count.reshape(self.numClass, self.numClass)
        # print(confusionMatrix)
        return confusionMatrix

    def Frequency_Weighted_Intersection_over_Union(self):
        """
        FWIoU，频权交并比:为MIoU的一种提升，这种方法根据每个类出现的频率为其设置权重。
        FWIOU =     [(TP+FN)/(TP+FP+TN+FN)] *[TP / (TP + FP + FN)]
        """
        freq = np.sum(self.confusion_matrix, axis=1) / np.sum(self.confusion_matrix)
        iu = np.diag(self.confusion_matrix) / (
                np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -
                np.diag(self.confusion_matrix))
        FWIoU = (freq[freq > 0] * iu[freq > 0]).sum()
        return FWIoU

    def addBatch(self, imgPredict, imgLabel):
        assert imgPredict.shape == imgLabel.shape
        self.confusionMatrix += self.genConfusionMatrix(imgPredict, imgLabel)  # 得到混淆矩阵
        return self.confusionMatrix

    def reset(self):
        self.confusionMatrix = np.zeros((self.numClass, self.numClass))


# 测试内容
if __name__ == '__main__':
    imgPredict = cv2.imread("../result/qqq.png")
    imgLabel = cv2.imread("../result/img.jpg")
    #"../result/standard/mask/SM50GRADE1PLAIN(1).jpg"
    #"../result/predict/image/SM50GRADE1BLANKET(1).jpg"

    imgPredict = np.array(cv2.cvtColor(imgPredict, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    imgLabel = np.array(cv2.cvtColor(imgLabel, cv2.COLOR_BGR2GRAY) / 255., dtype=np.uint8)
    # imgPredict = np.array([0, 0, 1, 1, 2, 2])  # 可直接换成预测图片
    # imgLabel = np.array([0, 0, 1, 1, 2, 2])  # 可直接换成标注图片

    metric = SegmentationMetric(2)  # 2表示有2个分类，有几个分类就填几
    ConfusionMatrix = metric.addBatch(imgPredict, imgLabel)
    pa = metric.pixelAccuracy()
    cpa = metric.classPixelAccuracy()
    mpa = metric.meanPixelAccuracy()
    IoU = metric.IntersectionOverUnion()
    mIoU = metric.meanIntersectionOverUnion()
    print('ConfusionMatrix is :\n', ConfusionMatrix)
    print('PA is : %f' % pa)
    print('cPA is :', cpa)
    print('mPA is : %f' % mpa)
    print('IoU is : ', IoU)
    print('mIoU is : ', mIoU)

效果图如下：
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/30351.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【网安神器篇】——Whatweb指纹识别工具

【网安神器篇】——Whatweb指纹识别工具

作者名&#xff1a;Demo不是emo 主页面链接&#xff1a;主页传送门创作初心&#xff1a;舞台再大&#xff0c;你不上台&#xff0c;永远是观众&#xff0c;没人会关心你努不努力&#xff0c;摔的痛不痛&#xff0c;他们只会看你最后站在什么位置&#xff0c;然后羡慕或鄙夷座右…
阅读更多...
CV—cs231n二刷

CV—cs231n二刷

文章目录cv应用优化训练牛顿法HOGYOLO风格迁移GAN语义分割实例分割LSTMDL框架GPU相关cs231n.stanford.edu cv应用 图像分类、目标检测、人脸识别、语义分割、风格迁移、GAN生成、VQA多模态、点云分割、姿态估计、游戏学习等 优化训练 避免后期训练还在大幅震荡&…
阅读更多...
[carla] GNSS传感器与Carla坐标系 转换方法

[carla] GNSS传感器与Carla坐标系 转换方法

文章目录方法1:通过python API直接获取转换后坐标1.1 GNSS传感器消息-内容介绍1.2 在线获取方法1.3 完整代码方法2-通过离线读取转换关系的方式转换2.1 转换类代码和使用方法2.2 转换矩阵保存和读取2.3 运行结果2.5 注意事项附件 所有地图的转换矩阵参考链接:方法1:通过python …
阅读更多...
工作中学到的一些小点

工作中学到的一些小点

1.结构体对齐 记得之前面试的时候被问过这个问题【汗】 这个结构体占多大 struct sExample {char c;int n; };占8字节&#xff0c;问有没有办法让它占5个字节&#xff1f; 有 #pragma pack(push) //保存对齐状态 #pragma pack(1) //设定为1字节对齐struct sExample {char c;…
阅读更多...
qt串口配置（端口号列表选择/自动保存/初始化模板）复制粘贴直接用

qt串口配置（端口号列表选择/自动保存/初始化模板）复制粘贴直接用

一、前言 废话不多说&#xff0c;写这个作为串口模板&#xff0c;后续会继续补充其他模板&#xff0c;有相识功能直接复制模板里东西到程序中&#xff0c;直接使用&#xff0c;无需大的调整&#xff0c;为自己模板记录&#xff0c;也提供给需要的朋友们。 二、环境 qt5.7 win…
阅读更多...
R15.3-15.3-15.3-15.3A_哈威泵_样本及应用

R15.3-15.3-15.3-15.3A_哈威泵_样本及应用

R15.3-15.3-15.3-15.3A_哈威泵_样本及应用R11.8-11.8-11.8-11.8-BABSL_水泥行业用主用于钢厂&#xff0c;油田&#xff0c;水利&#xff0c;飞机&#xff0c;压铸机等重型液压设备。 对油泵R11.8-11.8-11.8-11.8-BABSL_水泥行业用的维护保养应注意以下方面&#xff1a; 1.会腐…
阅读更多...
项目需求及架构设计

项目需求及架构设计

第2章 项目需求及架构设计 2.1 项目需求分析 用户行为数据采集平台搭建 用户行为数据会以文件的形式存储在服务器&#xff0c;这个阶段需要考虑&#xff1a;采集用户行为数据使用的工具,需要提供详细的设计需求 如&#xff1a;flume&#xff0c;flume采用的 source、channel、…
阅读更多...
HDFS的Shell操作

HDFS的Shell操作

该文章主要为完成实训任务及总结&#xff0c;详细实现过程及结果见【参考文章】 参考文章&#xff1a;https://howard2005.blog.csdn.net/article/details/127170478 文章目录一、 三种Shell命令方式二、FileSystem Shell文档三、常用Shell命令四、实例练习1、创建目录2、查看目…
阅读更多...
这位00后经历人生重大变故后，选择了智能家居，选择了Aqara绿米

这位00后经历人生重大变故后，选择了智能家居，选择了Aqara绿米

作者 | 布斯 编辑 | 小沐 出品 | 智哪儿 zhinaer.cn编者按&#xff1a;虽然概念由来已久&#xff0c;但智能家居如今依然属于新兴产业。而这样一个当今在全国范围遍地开花的新型商业存在&#xff0c;已经创造了许多的就业岗位与创业机会&#xff0c;也隐藏着许多让人回味的故事…
阅读更多...
Profinet总线模拟输出模块

Profinet总线模拟输出模块

上电后&#xff0c;耦合器自动识别所有与之相连的 I/O 模块&#xff0c;并根据模块的类型、数据宽度和模块在节点中的位置创建内部本地过程映像。 如果添加、更改或移除 I/O 模块&#xff0c;会建立新的过程映像&#xff0c;过程数据地址会改变。在添加 I/O 模块时&#xff0c…
阅读更多...
【MySQL】MySQL执行计划与SQL调优提高查询效率(优化篇)(实战篇)（MySQL专栏启动）

【MySQL】MySQL执行计划与SQL调优提高查询效率(优化篇)(实战篇)（MySQL专栏启动）

&#x1f4eb;作者简介&#xff1a;小明java问道之路&#xff0c;专注于研究 Java/ Liunx内核/ C及汇编/计算机底层原理/源码&#xff0c;就职于大型金融公司后端高级工程师&#xff0c;擅长交易领域的高安全/可用/并发/性能的架构设计与演进、系统优化与稳定性建设。 &#x1…
阅读更多...
Pixel Difference Networks for Efficient Edge Detection论文笔记

Pixel Difference Networks for Efficient Edge Detection论文笔记

文章目录一、背景知识二、Pixel Difference Convolution&#xff08;PDC&#xff09;1.CPDC2.APDC3.RPDC三、轻量化边缘检测网络A. Block_x_yB. CSAMC. CDCMD. 1*1卷积层E. 深度监督&#xff08;deep supervision&#xff09;F. 损失函数四、实验结果1. 消融实验2.网络可扩展性…
阅读更多...
SpringAMQP简介及简单使用

SpringAMQP简介及简单使用

一、SpringAMQP简介 SpringAMQP是基于RabbitMQ封装的一套模板&#xff0c;并且还利用SpringBoot对其实现了自动装配&#xff0c;使用起来非常方便。 SpringAmqp的官方地址&#xff1a;https://spring.io/projects/spring-amqp SpringAMQP提供了三个功能&#xff1a; 自动声明…
阅读更多...
Maven基础概念

Maven基础概念

仓库 仓库用于存储资源&#xff0c;包含各种jar包。 仓库分类&#xff1a; 本地仓库&#xff1a;自己电脑作为仓库&#xff0c;连接远程仓库获取资源。远程仓库&#xff1a;非本地的仓库&#xff0c;为本地仓库提供资源。中央仓库&#xff1a;由Maven团队维护&#xff0c;存…
阅读更多...
【Servlet】4：详解请求对象 HttpServletRequest

【Servlet】4：详解请求对象 HttpServletRequest

目录 | 请求对象 HttpServletRequest接口 HttpServletRequest的基本概述 请求对象获取 URL & Method 请求对象获取 参数名 请求对象获取 参数值 参数值乱码问题 本文章属于后端全套笔记的第三部分 &#xff08;更新中&#xff09;【后端入门到入土&#xff01;】Java…
阅读更多...
CAN电压测试

CAN电压测试

CAN总线&#xff1a; 一般用在汽车&#xff0c;伺服驱动器&#xff0c;步进驱动器&#xff0c;舵机&#xff0c;分布式io等设备上。 有以太网转CAN和4G网转CAN。 当然得到数据后&#xff0c;可以往RS485等上面转。 只需要2根线&#xff1a; H和L线&#xff0c;终端再并联120…
阅读更多...
Linux history 命令相关使用以及配置

Linux history 命令相关使用以及配置

Linux history 命令相关使用以及配置 Linux history 新手学习 shell 的时候都知道 history 命令能帮助我们查看之前运行的命令集合&#xff0c;通过这个能够帮我们回忆之前的命令&#xff0c;以及进行各种排错等等。 比如我们直接输入 history 进行查看&#xff1a; histor…
阅读更多...
Flutter高仿微信-第20篇-支付-充值

Flutter高仿微信-第20篇-支付-充值

Flutter高仿微信系列共59篇&#xff0c;从Flutter客户端、Kotlin客户端、Web服务器、数据库表结构、Xmpp即时通讯服务器、视频通话服务器、腾讯云服务器全面讲解。 详情请查看 效果图&#xff1a; 实现代码&#xff1a; /*** Author : wangning* Email : maoning20080809163.…
阅读更多...
Android AIDL跨进程通信基础（多端情况）

Android AIDL跨进程通信基础（多端情况）

简介 AIDL建议在来自不同的客户端访问你的服务并且需要处理多线程问题时你才必须使用AIDL&#xff0c;其他情况下你都可以选择其他方法&#xff0c;如使用 Messenger&#xff0c;也能跨进程通信。可见 AIDL 是处理多线程、多客户端并发访问的&#xff0c;而 Messenger 是单线程…
阅读更多...
年末盘点时间——用Python绘制饼状图对商品库存进行分析

年末盘点时间——用Python绘制饼状图对商品库存进行分析

人生苦短&#xff0c;我用python 存货盘点最重要的是什么&#xff0c;盘点比例要达到&#xff0c; 比如说要达到80%&#xff0c;于是就拿着企业给导的进销存明细表&#xff0c; 于是就开始筛选大金额的存货作为选择的样本&#xff0c; 这样就够比例了。 可是实际盘点的时候…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023