深度学习从入门到精通——基于unet++算法实现细胞分割

news2024/9/28 13:16:54

模型定义

import torch
from torch import nn

__all__ = ['UNet', 'NestedUNet']


class VGGBlock(nn.Module):
    def __init__(self, in_channels, middle_channels, out_channels):
        super().__init__()
        self.relu = nn.ReLU(inplace=True)
        self.conv1 = nn.Conv2d(in_channels, middle_channels, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(middle_channels)
        self.conv2 = nn.Conv2d(middle_channels, out_channels, 3, padding=1)
        self.bn2 = nn.BatchNorm2d(out_channels)

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        return out


class UNet(nn.Module):
    def __init__(self, num_classes, input_channels=3, **kwargs):
        super().__init__()

        nb_filter = [32, 64, 128, 256, 512]

        self.pool = nn.MaxPool2d(2, 2)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)#scale_factor:放大的倍数  插值

        self.conv0_0 = VGGBlock(input_channels, nb_filter[0], nb_filter[0])
        self.conv1_0 = VGGBlock(nb_filter[0], nb_filter[1], nb_filter[1])
        self.conv2_0 = VGGBlock(nb_filter[1], nb_filter[2], nb_filter[2])
        self.conv3_0 = VGGBlock(nb_filter[2], nb_filter[3], nb_filter[3])
        self.conv4_0 = VGGBlock(nb_filter[3], nb_filter[4], nb_filter[4])

        self.conv3_1 = VGGBlock(nb_filter[3]+nb_filter[4], nb_filter[3], nb_filter[3])
        self.conv2_2 = VGGBlock(nb_filter[2]+nb_filter[3], nb_filter[2], nb_filter[2])
        self.conv1_3 = VGGBlock(nb_filter[1]+nb_filter[2], nb_filter[1], nb_filter[1])
        self.conv0_4 = VGGBlock(nb_filter[0]+nb_filter[1], nb_filter[0], nb_filter[0])

        self.final = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)


    def forward(self, input):
        x0_0 = self.conv0_0(input)
        x1_0 = self.conv1_0(self.pool(x0_0))
        x2_0 = self.conv2_0(self.pool(x1_0))
        x3_0 = self.conv3_0(self.pool(x2_0))
        x4_0 = self.conv4_0(self.pool(x3_0))

        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))
        x2_2 = self.conv2_2(torch.cat([x2_0, self.up(x3_1)], 1))
        x1_3 = self.conv1_3(torch.cat([x1_0, self.up(x2_2)], 1))
        x0_4 = self.conv0_4(torch.cat([x0_0, self.up(x1_3)], 1))

        output = self.final(x0_4)
        return output


class NestedUNet(nn.Module):
    def __init__(self, num_classes, input_channels=3, deep_supervision=False, **kwargs):
        super().__init__()

        nb_filter = [32, 64, 128, 256, 512]

        self.deep_supervision = deep_supervision

        self.pool = nn.MaxPool2d(2, 2)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)

        self.conv0_0 = VGGBlock(input_channels, nb_filter[0], nb_filter[0])
        self.conv1_0 = VGGBlock(nb_filter[0], nb_filter[1], nb_filter[1])
        self.conv2_0 = VGGBlock(nb_filter[1], nb_filter[2], nb_filter[2])
        self.conv3_0 = VGGBlock(nb_filter[2], nb_filter[3], nb_filter[3])
        self.conv4_0 = VGGBlock(nb_filter[3], nb_filter[4], nb_filter[4])

        self.conv0_1 = VGGBlock(nb_filter[0]+nb_filter[1], nb_filter[0], nb_filter[0])
        self.conv1_1 = VGGBlock(nb_filter[1]+nb_filter[2], nb_filter[1], nb_filter[1])
        self.conv2_1 = VGGBlock(nb_filter[2]+nb_filter[3], nb_filter[2], nb_filter[2])
        self.conv3_1 = VGGBlock(nb_filter[3]+nb_filter[4], nb_filter[3], nb_filter[3])

        self.conv0_2 = VGGBlock(nb_filter[0]*2+nb_filter[1], nb_filter[0], nb_filter[0])
        self.conv1_2 = VGGBlock(nb_filter[1]*2+nb_filter[2], nb_filter[1], nb_filter[1])
        self.conv2_2 = VGGBlock(nb_filter[2]*2+nb_filter[3], nb_filter[2], nb_filter[2])

        self.conv0_3 = VGGBlock(nb_filter[0]*3+nb_filter[1], nb_filter[0], nb_filter[0])
        self.conv1_3 = VGGBlock(nb_filter[1]*3+nb_filter[2], nb_filter[1], nb_filter[1])

        self.conv0_4 = VGGBlock(nb_filter[0]*4+nb_filter[1], nb_filter[0], nb_filter[0])

        if self.deep_supervision:
            self.final1 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final2 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final3 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
            self.final4 = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)
        else:
            self.final = nn.Conv2d(nb_filter[0], num_classes, kernel_size=1)


    def forward(self, input):
        # print('input:',input.shape)
        x0_0 = self.conv0_0(input)
        # print('x0_0:',x0_0.shape)
        x1_0 = self.conv1_0(self.pool(x0_0))
        # print('x1_0:',x1_0.shape)
        x0_1 = self.conv0_1(torch.cat([x0_0, self.up(x1_0)], 1))
        # print('x0_1:',x0_1.shape)

        x2_0 = self.conv2_0(self.pool(x1_0))
        # print('x2_0:',x2_0.shape)
        x1_1 = self.conv1_1(torch.cat([x1_0, self.up(x2_0)], 1))
        # print('x1_1:',x1_1.shape)
        x0_2 = self.conv0_2(torch.cat([x0_0, x0_1, self.up(x1_1)], 1))
        # print('x0_2:',x0_2.shape)

        x3_0 = self.conv3_0(self.pool(x2_0))
        # print('x3_0:',x3_0.shape)
        x2_1 = self.conv2_1(torch.cat([x2_0, self.up(x3_0)], 1))
        # print('x2_1:',x2_1.shape)
        x1_2 = self.conv1_2(torch.cat([x1_0, x1_1, self.up(x2_1)], 1))
        # print('x1_2:',x1_2.shape)
        x0_3 = self.conv0_3(torch.cat([x0_0, x0_1, x0_2, self.up(x1_2)], 1))
        # print('x0_3:',x0_3.shape)
        x4_0 = self.conv4_0(self.pool(x3_0))
        # print('x4_0:',x4_0.shape)
        x3_1 = self.conv3_1(torch.cat([x3_0, self.up(x4_0)], 1))
        # print('x3_1:',x3_1.shape)
        x2_2 = self.conv2_2(torch.cat([x2_0, x2_1, self.up(x3_1)], 1))
        # print('x2_2:',x2_2.shape)
        x1_3 = self.conv1_3(torch.cat([x1_0, x1_1, x1_2, self.up(x2_2)], 1))
        # print('x1_3:',x1_3.shape)
        x0_4 = self.conv0_4(torch.cat([x0_0, x0_1, x0_2, x0_3, self.up(x1_3)], 1))
        # print('x0_4:',x0_4.shape)

        if self.deep_supervision:
            output1 = self.final1(x0_1)
            output2 = self.final2(x0_2)
            output3 = self.final3(x0_3)
            output4 = self.final4(x0_4)
            return [output1, output2, output3, output4]

        else:
            output = self.final(x0_4)
            return output

损失函数

BCEDiceLoss：
  • 这个损失函数结合了二元交叉熵损失（Binary Cross Entropy, BCE）和 Dice Loss。
  • BCE 于衡量模型输出和真实标签之间的二值化像素级别匹配情况。
  • Dice Loss 用于量模型输出和真实标签之间的相似度，但这里采用了一种稍微不同的计算方式，即将 Dice Loss 作为 1 减去 Dice 相似度的平均值，这样得到的损失越小，说明相似度越高。
LovaszHingeLoss：
  • 这个损失函数采用的是 Lovasz-Hinge Loss，它是一种用于处理不平衡数据集的损失函数，尤其适用于像素级别的分类任务。
  • Lovasz-Hinge Loss 能够更好地处理类别不平衡和边界情况，相比于交叉熵损失，在处理不平衡数据时更加稳定。
    LovaszHingeLoss相关介绍
测试用例：

lovasz_losses.py 相关内容

"""
Lovasz-Softmax and Jaccard hinge loss in PyTorch
Maxim Berman 2018 ESAT-PSI KU Leuven (MIT License)
"""

from __future__ import print_function, division

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import numpy as np

try:
    from itertools import ifilterfalse
except ImportError:  # py3k
    from itertools import filterfalse as ifilterfalse


def lovasz_grad(gt_sorted):
    """
    Computes gradient of the Lovasz extension w.r.t sorted errors
    See Alg. 1 in paper
    """
    p = len(gt_sorted)
    gts = gt_sorted.sum()
    intersection = gts - gt_sorted.float().cumsum(0)
    union = gts + (1 - gt_sorted).float().cumsum(0)
    jaccard = 1. - intersection / union
    if p > 1:  # cover 1-pixel case
        jaccard[1:p] = jaccard[1:p] - jaccard[0:-1]
    return jaccard


def iou_binary(preds, labels, EMPTY=1., ignore=None, per_image=True):
    """
    IoU for foreground class
    binary: 1 foreground, 0 background
    """
    if not per_image:
        preds, labels = (preds,), (labels,)
    ious = []
    for pred, label in zip(preds, labels):
        intersection = ((label == 1) & (pred == 1)).sum()
        union = ((label == 1) | ((pred == 1) & (label != ignore))).sum()
        if not union:
            iou = EMPTY
        else:
            iou = float(intersection) / float(union)
        ious.append(iou)
    iou = mean(ious)  # mean accross images if per_image
    return 100 * iou


def iou(preds, labels, C, EMPTY=1., ignore=None, per_image=False):
    """
    Array of IoU for each (non ignored) class
    """
    if not per_image:
        preds, labels = (preds,), (labels,)
    ious = []
    for pred, label in zip(preds, labels):
        iou = []
        for i in range(C):
            if i != ignore:  # The ignored label is sometimes among predicted classes (ENet - CityScapes)
                intersection = ((label == i) & (pred == i)).sum()
                union = ((label == i) | ((pred == i) & (label != ignore))).sum()
                if not union:
                    iou.append(EMPTY)
                else:
                    iou.append(float(intersection) / float(union))
        ious.append(iou)
    ious = [mean(iou) for iou in zip(*ious)]  # mean accross images if per_image
    return 100 * np.array(ious)


# --------------------------- BINARY LOSSES ---------------------------


def lovasz_hinge(logits, labels, per_image=True, ignore=None):
    """
    Binary Lovasz hinge loss
      logits: [B, H, W] Variable, logits at each pixel (between -\infty and +\infty)
      labels: [B, H, W] Tensor, binary ground truth masks (0 or 1)
      per_image: compute the loss per image instead of per batch
      ignore: void class id
    """
    if per_image:
        loss = mean(lovasz_hinge_flat(*flatten_binary_scores(log.unsqueeze(0), lab.unsqueeze(0), ignore))
                    for log, lab in zip(logits, labels))
    else:
        loss = lovasz_hinge_flat(*flatten_binary_scores(logits, labels, ignore))
    return loss


def lovasz_hinge_flat(logits, labels):
    """
    Binary Lovasz hinge loss
      logits: [P] Variable, logits at each prediction (between -\infty and +\infty)
      labels: [P] Tensor, binary ground truth labels (0 or 1)
      ignore: label to ignore
    """
    if len(labels) == 0:
        # only void pixels, the gradients should be 0
        return logits.sum() * 0.
    signs = 2. * labels.float() - 1.
    errors = (1. - logits * Variable(signs))
    errors_sorted, perm = torch.sort(errors, dim=0, descending=True)
    perm = perm.data
    gt_sorted = labels[perm]
    grad = lovasz_grad(gt_sorted)
    loss = torch.dot(F.relu(errors_sorted), Variable(grad))
    return loss


def flatten_binary_scores(scores, labels, ignore=None):
    """
    Flattens predictions in the batch (binary case)
    Remove labels equal to 'ignore'
    """
    scores = scores.view(-1)
    labels = labels.view(-1)
    if ignore is None:
        return scores, labels
    valid = (labels != ignore)
    vscores = scores[valid]
    vlabels = labels[valid]
    return vscores, vlabels


class StableBCELoss(torch.nn.modules.Module):
    def __init__(self):
        super(StableBCELoss, self).__init__()

    def forward(self, input, target):
        neg_abs = - input.abs()
        loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log()
        return loss.mean()


def binary_xloss(logits, labels, ignore=None):
    """
    Binary Cross entropy loss
      logits: [B, H, W] Variable, logits at each pixel (between -\infty and +\infty)
      labels: [B, H, W] Tensor, binary ground truth masks (0 or 1)
      ignore: void class id
    """
    logits, labels = flatten_binary_scores(logits, labels, ignore)
    loss = StableBCELoss()(logits, Variable(labels.float()))
    return loss


# --------------------------- MULTICLASS LOSSES ---------------------------


def lovasz_softmax(probas, labels, classes='present', per_image=False, ignore=None):
    """
    Multi-class Lovasz-Softmax loss
      probas: [B, C, H, W] Variable, class probabilities at each prediction (between 0 and 1).
              Interpreted as binary (sigmoid) output with outputs of size [B, H, W].
      labels: [B, H, W] Tensor, ground truth labels (between 0 and C - 1)
      classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
      per_image: compute the loss per image instead of per batch
      ignore: void class labels
    """
    if per_image:
        loss = mean(lovasz_softmax_flat(*flatten_probas(prob.unsqueeze(0), lab.unsqueeze(0), ignore), classes=classes)
                    for prob, lab in zip(probas, labels))
    else:
        loss = lovasz_softmax_flat(*flatten_probas(probas, labels, ignore), classes=classes)
    return loss


def lovasz_softmax_flat(probas, labels, classes='present'):
    """
    Multi-class Lovasz-Softmax loss
      probas: [P, C] Variable, class probabilities at each prediction (between 0 and 1)
      labels: [P] Tensor, ground truth labels (between 0 and C - 1)
      classes: 'all' for all, 'present' for classes present in labels, or a list of classes to average.
    """
    if probas.numel() == 0:
        # only void pixels, the gradients should be 0
        return probas * 0.
    C = probas.size(1)
    losses = []
    class_to_sum = list(range(C)) if classes in ['all', 'present'] else classes
    for c in class_to_sum:
        fg = (labels == c).float()  # foreground for class c
        if (classes == 'present' and fg.sum() == 0):
            continue
        if C == 1:
            if len(classes) > 1:
                raise ValueError('Sigmoid output possible only with 1 class')
            class_pred = probas[:, 0]
        else:
            class_pred = probas[:, c]
        errors = (Variable(fg) - class_pred).abs()
        errors_sorted, perm = torch.sort(errors, 0, descending=True)
        perm = perm.data
        fg_sorted = fg[perm]
        losses.append(torch.dot(errors_sorted, Variable(lovasz_grad(fg_sorted))))
    return mean(losses)


def flatten_probas(probas, labels, ignore=None):
    """
    Flattens predictions in the batch
    """
    if probas.dim() == 3:
        # assumes output of a sigmoid layer
        B, H, W = probas.size()
        probas = probas.view(B, 1, H, W)
    B, C, H, W = probas.size()
    probas = probas.permute(0, 2, 3, 1).contiguous().view(-1, C)  # B * H * W, C = P, C
    labels = labels.view(-1)
    if ignore is None:
        return probas, labels
    valid = (labels != ignore)
    vprobas = probas[valid.nonzero().squeeze()]
    vlabels = labels[valid]
    return vprobas, vlabels


def xloss(logits, labels, ignore=None):
    """
    Cross entropy loss
    """
    return F.cross_entropy(logits, Variable(labels), ignore_index=255)


# --------------------------- HELPER FUNCTIONS ---------------------------
def isnan(x):
    return x != x


def mean(l, ignore_nan=False, empty=0):
    """
    nanmean compatible with generators.
    """
    l = iter(l)
    if ignore_nan:
        l = ifilterfalse(isnan, l)
    try:
        n = 1
        acc = next(l)
    except StopIteration:
        if empty == 'raise':
            raise ValueError('Empty mean')
        return empty
    for n, v in enumerate(l, 2):
        acc += v
    if n == 1:
        return acc
    return acc / n


import torch
import torch.nn as nn
import torch.nn.functional as F
from lovasz_losses import lovasz_hinge

# __all__ = ['BCEDiceLoss', 'LovaszHingeLoss']


class BCEDiceLoss(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, input, target):


        bce = F.binary_cross_entropy_with_logits(input, target)
        smooth = 1e-5
        input = torch.sigmoid(input)
        num = target.size(0)
        input = input.view(num, -1)
        target = target.view(num, -1)
        intersection = (input * target)
        dice = (2. * intersection.sum(1) + smooth) / (input.sum(1) + target.sum(1) + smooth)
        dice = 1 - dice.sum() / num
        return 0.5 * bce + dice


class LovaszHingeLoss(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, input, target):
        input = input.squeeze(1)
        target = target.squeeze(1)
        loss = lovasz_hinge(input, target, per_image=True)

        return loss


if __name__ == '__main__':
    import torch

    # 假设模型输出和真实标签都是二值化的图像，大小为(1, H, W)
    output = torch.tensor([[[0.3, 0.7], [0.8, 0.6]]])  # 模型输出
    # output = output.round().long()


    target = torch.tensor([[[0, 1], [1, 0]]],dtype=torch.float)  # 真实标签

    bce_dice_loss = BCEDiceLoss()
    bce_dice = bce_dice_loss(output, target)

    lovasz_hinge_loss = LovaszHingeLoss()
    lovasz_hinge = lovasz_hinge_loss(output, target)

    print("BCE Dice Loss:", bce_dice)
    print("Lovasz Hinge Loss:", lovasz_hinge)

原理解释和数学公式：

BCEDiceLoss 原理：
  • BCE Dice Loss 结合了二元交叉熵损失和 Dice Loss。其数学表达式如下：

B C E _ D i c e _ L o s s = 0.5 × B C E + ( 1 − D i c e ) BCE\_Dice\_Loss = 0.5 \times BCE + (1 - Dice) BCE_Dice_Loss=0.5×BCE+(1−Dice)

其中， B C E BCE BCE 表示二元交叉熵损失， D i c e Dice Dice 表示 Dice 相似度。这个损失函数的目标是最小化二元交叉熵损失和最大化 Dice 相似度，以达到更好的模型训练效果。

LovaszHingeLoss 原理：
  • Lovasz-Hinge Loss 是一种非平衡数据集上的损失函数，用于像素级别的分类任务。其数学表达式如下：

L o v a s z _ H i n g e _ L o s s = lovasz_hinge ( i n p u t , t a r g e t ) Lovasz\_Hinge\_Loss = \text{lovasz\_hinge}(input, target) Lovasz_Hinge_Loss=lovasz_hinge(input,target)

这里的 lovasz_hinge \text{lovasz\_hinge} lovasz_hinge 是一个函数，用于计算 Lovasz-Hinge Loss。

训练

√

评估函数

metrics.py

import numpy as np
import torch
import torch.nn.functional as F


def iou_score(output, target):
    smooth = 1e-5

    if torch.is_tensor(output):
        output = torch.sigmoid(output).data.cpu().numpy()
    if torch.is_tensor(target):
        target = target.data.cpu().numpy()
    output_ = output > 0.5
    target_ = target > 0.5
    intersection = (output_ & target_).sum()
    union = (output_ | target_).sum()

    return (intersection + smooth) / (union + smooth)


def dice_coef(output, target):
    smooth = 1e-5

    output = torch.sigmoid(output).view(-1).data.cpu().numpy()
    target = target.view(-1).data.cpu().numpy()
    intersection = (output * target).sum()

    return (2. * intersection + smooth) / \
        (output.sum() + target.sum() + smooth)


if __name__ == '__main__':
    import numpy as np
    import torch

    # 假设模型输出和真实标签都是二值化的图像，大小为(1, H, W)
    output = torch.tensor([[[0.3, 0.7], [0.8, 0.6]]])  # 模型输出
    target = torch.tensor([[[0, 1], [1, 0]]])  # 真实标签

    iou = iou_score(output, target)
    dice = dice_coef(output, target)

    print("IoU Score:", iou)
    print("Dice Coefficient:", dice)

在这里插入图片描述

IoU（Intersection over Union）评分函数原理

IoU 是一种常用的图像分割评价指标，它衡量了模型输出与真实标签之间的重程度。其数学公式如下：

I o U = T P T P + F P + F N IoU = \frac{{TP}}{{TP + FP + FN}} IoU=TP+FP+FNTP​

其中， T P TP TP 表示真正例（模型正确预测为正样本的数量）， F P FP FP 表示假正例（模型错误预测为正样本的数量）， F N FN FN 表示假负例（模型错误预测为负样本的数量）。

Dice Coefficient评分函数原理

Dice Coefficient 也是一种常用的图像分割评价指标，衡量模型输出和真实标签之间的相似度。其数学公式如下：

D i c e = 2 × T P 2 × T P + F P + F N Dice = \frac{{2 \times TP}}{{2 \times TP + FP + FN}} Dice=2×TP+FP+FN2×TP​

其中， T P TP TP 表示真正例， F P FP FP 表示假正例， F N FN FN 表示假负例，与 IoU 公式中的定义相同。

这两个评分函数都以模型的真正例为分子，而分母则是真正例、假正例和假负例的总和，以此来衡量模型预测结果与真实标签的相似程度。公式中的平滑因子用于避免分母为零的情况，增加了数值稳定性。

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

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

相关文章

matlab实现简单的保角变换

matlab实现简单的保角变换

用虚数的思想可以在虚坐标系内绘制圆，同样可以用虚数的想法将这个圆进行变换 用MATLAB绘制一个坐标在(1,1)的圆代码如下 % 定义半径和圆心 radius 10; center 1 1i; % 圆心位于 (1,1) % 创建角度向量，从0到2*pi theta linspace(0, 2*pi, 100);% 计…
阅读更多...
运算放大器组成的比较器

运算放大器组成的比较器

D1,D2为5.3V稳压管。运放输出高时，为6V.运放输入1V，运放正端为2V. 运放输出低时，为-6V，运放输入4V，运放正端约为2V，实测值2.03V
阅读更多...
JavaScript 实现虚拟滚动技术

JavaScript 实现虚拟滚动技术

虚拟滚动 虚拟滚动（有时称为 虚拟列表、虚拟滚动条）是 JavaScript 中的一种技术，旨在优化大数据量的列表渲染，尤其是当有成千上万的数据项时，直接渲染整个列表会导致性能问题。虚拟列表通过只渲染用户视口中可见的那一…
阅读更多...
【HuggingFace Transformers】OpenAIGPTModel源码解析

【HuggingFace Transformers】OpenAIGPTModel源码解析

OpenAIGPTModel源码解析 1. GPT 介绍2. OpenAIGPTModel类 源码解析 说到ChatGPT，大家可能都使用过吧。2022年，ChatGPT的推出引发了广泛的关注和讨论。这款对话生成模型不仅具备了强大的语言理解和生成能力，还能进行非常自然的对话&#xff0c…
阅读更多...
手机免费录屏软件，这3款软件最佳选择

手机免费录屏软件，这3款软件最佳选择

在数字化浪潮的推动下，智能手机已成为我们生活中不可或缺的一部分。而在这些小巧而强大的设备中，录屏功能逐渐崭露头角，成为记录屏幕精彩瞬间的得力助手。无论是游戏的高光时刻、APP的使用教程，还是进行远程会议，录屏功…
阅读更多...
2024自动化测试面试真题（附答案）！

2024自动化测试面试真题（附答案）！

一、编程语法题 1 、 python 有哪些数据类型 python 数据类型有很多，基本数据类型有整型（数字）、字符串、元组、列表、字典和布尔类型等 2 、怎么将两个字典合并 调用字典的 update 方法，合并 2 个字典。 3 、 json.l python 如…
阅读更多...
HarmonyOS NEXT 体验调用云数据库更新排行榜单

HarmonyOS NEXT 体验调用云数据库更新排行榜单

一、介绍 基于鸿蒙Next模拟一个排行帮单二、场景需求 1.目标用户 社交平台用户，尤其是热衷于获取和分享信息的年轻人和用户群体。 2. 功能描述 用户可以通过“排行帮单”功能查看某个主题或领域的热门内容，并能够向朋友或群体推荐特定的项目。 3. 需求…
阅读更多...
数据治理与标准推动数据成为“金矿”

数据治理与标准推动数据成为“金矿”

方案介绍： 数据治理是一个涉及组织、政策、流程和技术的综合性框架，旨在确保数据的质量、安全性、可用性、合规性和一致性。它涵盖了从数据产生到销毁的全生命周期管理，确保数据在组织内部得到正确、高效地使用。而数据标准是数据治理的基石…
阅读更多...
OPenCV结构分析与形状描述符（2）计算轮廓周长的函数arcLength()的使用

OPenCV结构分析与形状描述符（2）计算轮廓周长的函数arcLength()的使用

操作系统：ubuntu22.04 OpenCV版本：OpenCV4.9 IDE:Visual Studio Code 编程语言：C11 算法描述 计算轮廓的周长或曲线的长度。 该函数计算曲线的长度或闭合轮廓的周长。 如果曲线是闭合的（即首尾相连），则计…
阅读更多...
CSS解析：层叠、优先级和继承

CSS解析：层叠、优先级和继承

CSS虽说不是编程语言，但是日常使用中经常有很多误解，发现样式不奏效的情况，所以需要加强下CSS基础。 CSS本质上就是声明规则，即在各种条件下，我们希望产生特定的效果。 如果某个元素有这个类，则应用这些样…
阅读更多...
英文翻译哪家强？2024年3款热门工具大比拼

英文翻译哪家强？2024年3款热门工具大比拼

现在世界变得越来越“小”，英语几乎成了大家都懂的语言。但对那些天天忙工作的小伙伴们来说，一大堆英文的东西，比如文件、邮件、会议记录，看着就头大。好在，科技帮了大忙，出了好多翻译工具。2024年&#xf…
阅读更多...
php邮箱服务器怎么搭建？如何构建服务器？

php邮箱服务器怎么搭建？如何构建服务器？

php邮箱服务器配置教程指南？php邮件服务器如何搭建？ 搭建一个稳定高效的php邮箱服务器，不仅可以提升邮件传输的效率，还能增强数据的安全性。那么，如何着手搭建这样一个服务器呢？AokSend将详细探讨php邮箱服…
阅读更多...
使用YOLOv10训练自定义数据集之一（环境部署）

使用YOLOv10训练自定义数据集之一（环境部署）

0x00 前言 由清华大学的研究团队基于 Ultralytics Python 包研发的 YOLOv10，通过优化模型结构并去除非极大值抑制（NMS）环节，提出了一种创新的实时目标检测技术。这些改进不仅实现了行业领先的检测性能，还降低了对计算…
阅读更多...
网络编程----网络基础ip地址

网络编程----网络基础ip地址

一丶IP地址 1.基本概念 1. IP地址是Internet中主机的标识 2. Internet中的主机要与别的机器通信必须具有一个IP地址 3. IP地址为32位（IPv4）或者128位（IPv6） NAT：公网转私网、私网转公网 4. IPV4表示形式&…
阅读更多...
【简历】25届上海某一本JAVA简历：第一次看学校背景写一页的

【简历】25届上海某一本JAVA简历：第一次看学校背景写一页的

注：为保证用户信息安全，姓名和学校等信息已经进行同层次变更，内容部分细节也进行了部分隐藏 简历说明 这是一份25 届上海某一本大学硕士的Java简历。这份简历写得比较偏，让人头疼。 这位同学的学校是重点一本，可以冲…
阅读更多...
C++第四十五弹---深入理解包装器：提升代码复用性与安全性的利器

C++第四十五弹---深入理解包装器：提升代码复用性与安全性的利器

✨个人主页： 熬夜学编程的小林 💗系列专栏： 【C语言详解】 【数据结构详解】【C详解】 目录 1 包装器 1.1、function包装器 1.2、bind 1 包装器 1.1、function包装器 function包装器 也叫作适配器。C中的function本质是一个类模板&…
阅读更多...
uniapp树洞烦恼分享系统 微信小程序设计与实现 80igt

uniapp树洞烦恼分享系统 微信小程序设计与实现 80igt

目录 博主介绍技术栈系统设计🌟文末获取源码数据库🌟具体实现截图后端前端java类核心代码部分展示可行性论证个人心得系统测试操作可行性源码获取详细视频演示 博主介绍 👇🏻 博主介绍：👇🏻 专…
阅读更多...
使用 WARP 和 Perf 测试对 MinIO 企业对象存储进行基准测试

使用 WARP 和 Perf 测试对 MinIO 企业对象存储进行基准测试

AI/ML、高级分析和数据库等现代应用程序需要高性能对象存储。MinIO Enterprise Object Store 将可扩展性和高性能相结合，使每个工作负载（无论要求多么苛刻）触手可及。我们发布的基准测试表明，MinIO Enterprise Object Storage 是市…
阅读更多...
泰克Tektronix MSO46 一款混合信号示波器

泰克Tektronix MSO46 一款混合信号示波器

Tektronix MSO46 是一款混合信号示波器 (MSO)，专为调试和分析复杂的电子电路而设计。FlexChannel 技术使每个通道输入都可以用作单个模拟通道、八个数字逻辑输入（使用 TLP058 逻辑探头）或同时使用模拟和频谱视图，每个域都有独立的…
阅读更多...
前端进阶｜一文理解柯里化的逆操作，什么是反柯里化

前端进阶｜一文理解柯里化的逆操作，什么是反柯里化

温故而知新 在说反柯里化之前，先来复习下柯里化的基础。之前文章，我们了解了什么是柯里化，以及柯里化的实现原理，同时我们也明白了什么情况下我们使用柯里化，详细阅读参见之前文章《前端进阶｜由浅入深的理…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023