【Unet系列】

news2024/11/15 11:14:07

https://tianfeng.space/1947.html

前言概念

图像分割

分割任务就是在原始图像中逐像素的找到你需要的家伙!

img

语义分割

就是把每个像素都打上标签（这个像素点是人，树，背景等）

（语义分割只区分类别，不区分类别中具体单位）img

实例分割

实例分割不光要区别类别，还要区分类别中每一个个体

img

损失函数：

逐像素的交叉熵：还经常需要考虑样本均衡问题，交叉熵损失函数公式如下：

img

Focal loss：样本也由难易之分，就跟玩游戏一样，难度越高的BOSS奖励越高

img
Gamma通常设置为2，例如预测正样本概率0.95，如果预测正样本概率0.4， （相当于样本的难易权值）

img
（再结合样本数量的权值就是Focal Loss）

IOU计算

多分类任务时：iou_dog = 801 / true_dog + predict_dog - 801

img

MIOU指标：
MIOU就是计算所有类别的平均值，一般当作分割任务评估指标

Unet

整体结构：概述就是编码解码过程；简单但是很实用，应用广；起初是做医学方向，现在也是

img

Unet++

整体网络结构：特征融合，拼接更全面；其实跟densenet思想一致；把能拼能凑的特征全用上

Deep Supervision ：多输出损失；由多个位置计算，再更新

容易剪枝：可以根据速度要求来快速完成剪枝；训练的时候同样会用到L4，效果还不错

img

U²net

代码 论文

听名字知道就是把Unet中每个stage再变成一个Unet，这样就嵌套了一个Unet变成U²net；

输出为解码器各个阶段输出再拼接，经过一次卷积输出

img

现有卷积块和我们提出的残差U形块RSU的说明：（a）普通卷积块PLN，（b）残差类块RES，（c）密集类块DSE，（d）启始类块INC和（e）我们的残差U型块RSU

img

残差块与我们的RSU的比较

img

就作者展示的效果而言，出奇的不错，有兴趣去代码界面看看，使用也很简单，下面展示一些

img

img

img

代码结构放最后；有兴趣看看

#U²net结构；387行forward开始
import torch
import torch.nn as nn
from torchvision import models
import torch.nn.functional as F

class REBNCONV(nn.Module):
    def __init__(self,in_ch=3,out_ch=3,dirate=1):
        super(REBNCONV,self).__init__()

        self.conv_s1 = nn.Conv2d(in_ch,out_ch,3,padding=1*dirate,dilation=1*dirate)
        self.bn_s1 = nn.BatchNorm2d(out_ch)
        self.relu_s1 = nn.ReLU(inplace=True)

    def forward(self,x):

        hx = x
        xout = self.relu_s1(self.bn_s1(self.conv_s1(hx)))

        return xout

## upsample tensor 'src' to have the same spatial size with tensor 'tar'
def _upsample_like(src,tar):

    src = F.upsample(src,size=tar.shape[2:],mode='bilinear')

    return src


### RSU-7 ###
class RSU7(nn.Module):#UNet07DRES(nn.Module):

    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
        super(RSU7,self).__init__()

        self.rebnconvin = REBNCONV(in_ch,out_ch,dirate=1)

        self.rebnconv1 = REBNCONV(out_ch,mid_ch,dirate=1)
        self.pool1 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool2 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool3 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv4 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool4 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv5 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool5 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv6 = REBNCONV(mid_ch,mid_ch,dirate=1)

        self.rebnconv7 = REBNCONV(mid_ch,mid_ch,dirate=2)

        self.rebnconv6d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv5d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv4d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv3d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch*2,out_ch,dirate=1)

    def forward(self,x):
        print(x.shape)
        hx = x
        hxin = self.rebnconvin(hx)
        print(hxin.shape)
        hx1 = self.rebnconv1(hxin)
        print(hx1.shape)
        hx = self.pool1(hx1)
        print(hx.shape)

        hx2 = self.rebnconv2(hx)
        print(hx2.shape)
        hx = self.pool2(hx2)
        print(hx.shape)

        hx3 = self.rebnconv3(hx)
        print(hx3.shape)
        hx = self.pool3(hx3)
        print(hx.shape)

        hx4 = self.rebnconv4(hx)
        print(hx4.shape)
        hx = self.pool4(hx4)
        print(hx.shape)

        hx5 = self.rebnconv5(hx)
        print(hx5.shape)
        hx = self.pool5(hx5)
        print(hx.shape)

        hx6 = self.rebnconv6(hx)
        print(hx6.shape)

        hx7 = self.rebnconv7(hx6)
        print(hx7.shape)

        hx6d =  self.rebnconv6d(torch.cat((hx7,hx6),1))
        print(hx6d.shape)
        hx6dup = _upsample_like(hx6d,hx5)
        print(hx6dup.shape)

        hx5d =  self.rebnconv5d(torch.cat((hx6dup,hx5),1))
        print(hx5d.shape)
        hx5dup = _upsample_like(hx5d,hx4)
        print(hx5dup.shape)

        hx4d = self.rebnconv4d(torch.cat((hx5dup,hx4),1))
        print(hx4d.shape)
        hx4dup = _upsample_like(hx4d,hx3)
        print(hx4dup.shape)

        hx3d = self.rebnconv3d(torch.cat((hx4dup,hx3),1))
        print(hx3d.shape)
        hx3dup = _upsample_like(hx3d,hx2)
        print(hx3dup.shape)

        hx2d = self.rebnconv2d(torch.cat((hx3dup,hx2),1))
        print(hx2d.shape)
        hx2dup = _upsample_like(hx2d,hx1)
        print(hx2dup.shape)

        hx1d = self.rebnconv1d(torch.cat((hx2dup,hx1),1))
        print(hx1d.shape)

        return hx1d + hxin

### RSU-6 ###
class RSU6(nn.Module):#UNet06DRES(nn.Module):

    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
        super(RSU6,self).__init__()

        self.rebnconvin = REBNCONV(in_ch,out_ch,dirate=1)

        self.rebnconv1 = REBNCONV(out_ch,mid_ch,dirate=1)
        self.pool1 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool2 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool3 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv4 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool4 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv5 = REBNCONV(mid_ch,mid_ch,dirate=1)

        self.rebnconv6 = REBNCONV(mid_ch,mid_ch,dirate=2)

        self.rebnconv5d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv4d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv3d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch*2,out_ch,dirate=1)

    def forward(self,x):

        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)
        hx = self.pool3(hx3)

        hx4 = self.rebnconv4(hx)
        hx = self.pool4(hx4)

        hx5 = self.rebnconv5(hx)

        hx6 = self.rebnconv6(hx5)


        hx5d =  self.rebnconv5d(torch.cat((hx6,hx5),1))
        hx5dup = _upsample_like(hx5d,hx4)

        hx4d = self.rebnconv4d(torch.cat((hx5dup,hx4),1))
        hx4dup = _upsample_like(hx4d,hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4dup,hx3),1))
        hx3dup = _upsample_like(hx3d,hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup,hx2),1))
        hx2dup = _upsample_like(hx2d,hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup,hx1),1))

        return hx1d + hxin

### RSU-5 ###
class RSU5(nn.Module):#UNet05DRES(nn.Module):

    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
        super(RSU5,self).__init__()

        self.rebnconvin = REBNCONV(in_ch,out_ch,dirate=1)

        self.rebnconv1 = REBNCONV(out_ch,mid_ch,dirate=1)
        self.pool1 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool2 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool3 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv4 = REBNCONV(mid_ch,mid_ch,dirate=1)

        self.rebnconv5 = REBNCONV(mid_ch,mid_ch,dirate=2)

        self.rebnconv4d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv3d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch*2,out_ch,dirate=1)

    def forward(self,x):

        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)
        hx = self.pool3(hx3)

        hx4 = self.rebnconv4(hx)

        hx5 = self.rebnconv5(hx4)

        hx4d = self.rebnconv4d(torch.cat((hx5,hx4),1))
        hx4dup = _upsample_like(hx4d,hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4dup,hx3),1))
        hx3dup = _upsample_like(hx3d,hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup,hx2),1))
        hx2dup = _upsample_like(hx2d,hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup,hx1),1))

        return hx1d + hxin

### RSU-4 ###
class RSU4(nn.Module):#UNet04DRES(nn.Module):

    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
        super(RSU4,self).__init__()

        self.rebnconvin = REBNCONV(in_ch,out_ch,dirate=1)

        self.rebnconv1 = REBNCONV(out_ch,mid_ch,dirate=1)
        self.pool1 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv2 = REBNCONV(mid_ch,mid_ch,dirate=1)
        self.pool2 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.rebnconv3 = REBNCONV(mid_ch,mid_ch,dirate=1)

        self.rebnconv4 = REBNCONV(mid_ch,mid_ch,dirate=2)

        self.rebnconv3d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv2d = REBNCONV(mid_ch*2,mid_ch,dirate=1)
        self.rebnconv1d = REBNCONV(mid_ch*2,out_ch,dirate=1)

    def forward(self,x):

        hx = x

        hxin = self.rebnconvin(hx)

        hx1 = self.rebnconv1(hxin)
        hx = self.pool1(hx1)

        hx2 = self.rebnconv2(hx)
        hx = self.pool2(hx2)

        hx3 = self.rebnconv3(hx)

        hx4 = self.rebnconv4(hx3)

        hx3d = self.rebnconv3d(torch.cat((hx4,hx3),1))
        hx3dup = _upsample_like(hx3d,hx2)

        hx2d = self.rebnconv2d(torch.cat((hx3dup,hx2),1))
        hx2dup = _upsample_like(hx2d,hx1)

        hx1d = self.rebnconv1d(torch.cat((hx2dup,hx1),1))

        return hx1d + hxin

### RSU-4F ###
class RSU4F(nn.Module):#UNet04FRES(nn.Module):

    def __init__(self, in_ch=3, mid_ch=12, out_ch=3):
        super(RSU4F,self).__init__()

        self.rebnconvin = REBNCONV(in_ch,out_ch,dirate=1)

        self.rebnconv1 = REBNCONV(out_ch,mid_ch,dirate=1)
        self.rebnconv2 = REBNCONV(mid_ch,mid_ch,dirate=2)
        self.rebnconv3 = REBNCONV(mid_ch,mid_ch,dirate=4)

        self.rebnconv4 = REBNCONV(mid_ch,mid_ch,dirate=8)

        self.rebnconv3d = REBNCONV(mid_ch*2,mid_ch,dirate=4)
        self.rebnconv2d = REBNCONV(mid_ch*2,mid_ch,dirate=2)
        self.rebnconv1d = REBNCONV(mid_ch*2,out_ch,dirate=1)

    def forward(self,x):

        hx = x

        hxin = self.rebnconvin(hx)
        print(hxin.shape)
        hx1 = self.rebnconv1(hxin)
        print(hx1.shape)
        hx2 = self.rebnconv2(hx1)
        print(hx2.shape)
        hx3 = self.rebnconv3(hx2)
        print(hx3.shape)

        hx4 = self.rebnconv4(hx3)
        print(hx4.shape)
        hx3d = self.rebnconv3d(torch.cat((hx4,hx3),1))
        print(hx3d.shape)
        hx2d = self.rebnconv2d(torch.cat((hx3d,hx2),1))
        print(hx2d.shape)
        hx1d = self.rebnconv1d(torch.cat((hx2d,hx1),1))
        print(hx1d.shape)

        return hx1d + hxin


##### U^2-Net ####
class U2NET(nn.Module):

    def __init__(self,in_ch=3,out_ch=1):
        super(U2NET,self).__init__()

        self.stage1 = RSU7(in_ch,32,64)
        self.pool12 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage2 = RSU6(64,32,128)
        self.pool23 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage3 = RSU5(128,64,256)
        self.pool34 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage4 = RSU4(256,128,512)
        self.pool45 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage5 = RSU4F(512,256,512)
        self.pool56 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage6 = RSU4F(512,256,512)

        # decoder
        self.stage5d = RSU4F(1024,256,512)
        self.stage4d = RSU4(1024,128,256)
        self.stage3d = RSU5(512,64,128)
        self.stage2d = RSU6(256,32,64)
        self.stage1d = RSU7(128,16,64)

        self.side1 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side2 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side3 = nn.Conv2d(128,out_ch,3,padding=1)
        self.side4 = nn.Conv2d(256,out_ch,3,padding=1)
        self.side5 = nn.Conv2d(512,out_ch,3,padding=1)
        self.side6 = nn.Conv2d(512,out_ch,3,padding=1)

        self.outconv = nn.Conv2d(6,out_ch,1)

    def forward(self,x):
        print(x.shape)
        hx = x

        #stage 1
        hx1 = self.stage1(hx)
        print(hx1.shape)
        hx = self.pool12(hx1)
        print(hx.shape)
        #stage 2
        hx2 = self.stage2(hx)
        print(hx2.shape)
        hx = self.pool23(hx2)
        print(hx.shape)

        #stage 3
        hx3 = self.stage3(hx)
        print(hx3.shape)
        hx = self.pool34(hx3)
        print(hx.shape)

        #stage 4
        hx4 = self.stage4(hx)
        print(hx4.shape)
        hx = self.pool45(hx4)
        print(hx.shape)

        #stage 5
        hx5 = self.stage5(hx)
        print(hx5.shape)
        hx = self.pool56(hx5)
        print(hx.shape)

        #stage 6
        hx6 = self.stage6(hx)
        print(hx6.shape)
        hx6up = _upsample_like(hx6,hx5)
        print(hx6up.shape)

        #-------------------- decoder --------------------
        hx5d = self.stage5d(torch.cat((hx6up,hx5),1))
        print(hx5d.shape)
        hx5dup = _upsample_like(hx5d,hx4)
        print(hx5dup.shape)
        hx4d = self.stage4d(torch.cat((hx5dup,hx4),1))
        print(hx4d.shape)
        hx4dup = _upsample_like(hx4d,hx3)
        print(hx4dup.shape)

        hx3d = self.stage3d(torch.cat((hx4dup,hx3),1))
        print(hx3d.shape)
        hx3dup = _upsample_like(hx3d,hx2)
        print(hx3dup.shape)

        hx2d = self.stage2d(torch.cat((hx3dup,hx2),1))
        print(hx2d.shape)
        hx2dup = _upsample_like(hx2d,hx1)
        print(hx2dup.shape)

        hx1d = self.stage1d(torch.cat((hx2dup,hx1),1))
        print(hx1d.shape)


        #side output
        d1 = self.side1(hx1d)
        print(d1.shape)

        d2 = self.side2(hx2d)
        print(d2.shape)
        d2 = _upsample_like(d2,d1)
        print(d2.shape)

        d3 = self.side3(hx3d)
        print(d3.shape)
        d3 = _upsample_like(d3,d1)
        print(d3.shape)

        d4 = self.side4(hx4d)
        print(d4.shape)
        d4 = _upsample_like(d4,d1)
        print(d4.shape)

        d5 = self.side5(hx5d)
        print(d5.shape)
        d5 = _upsample_like(d5,d1)
        print(d5.shape)

        d6 = self.side6(hx6)
        print(d6.shape)
        d6 = _upsample_like(d6,d1)
        print(d6.shape)

        d0 = self.outconv(torch.cat((d1,d2,d3,d4,d5,d6),1))
        print(d0.shape)

        return F.sigmoid(d0), F.sigmoid(d1), F.sigmoid(d2), F.sigmoid(d3), F.sigmoid(d4), F.sigmoid(d5), F.sigmoid(d6)

### U^2-Net small ###
class U2NETP(nn.Module):

    def __init__(self,in_ch=3,out_ch=1):
        super(U2NETP,self).__init__()

        self.stage1 = RSU7(in_ch,16,64)
        self.pool12 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage2 = RSU6(64,16,64)
        self.pool23 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage3 = RSU5(64,16,64)
        self.pool34 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage4 = RSU4(64,16,64)
        self.pool45 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage5 = RSU4F(64,16,64)
        self.pool56 = nn.MaxPool2d(2,stride=2,ceil_mode=True)

        self.stage6 = RSU4F(64,16,64)

        # decoder
        self.stage5d = RSU4F(128,16,64)
        self.stage4d = RSU4(128,16,64)
        self.stage3d = RSU5(128,16,64)
        self.stage2d = RSU6(128,16,64)
        self.stage1d = RSU7(128,16,64)

        self.side1 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side2 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side3 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side4 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side5 = nn.Conv2d(64,out_ch,3,padding=1)
        self.side6 = nn.Conv2d(64,out_ch,3,padding=1)

        self.outconv = nn.Conv2d(6,out_ch,1)

    def forward(self,x):

        hx = x

        #stage 1
        hx1 = self.stage1(hx)
        hx = self.pool12(hx1)

        #stage 2
        hx2 = self.stage2(hx)
        hx = self.pool23(hx2)

        #stage 3
        hx3 = self.stage3(hx)
        hx = self.pool34(hx3)

        #stage 4
        hx4 = self.stage4(hx)
        hx = self.pool45(hx4)

        #stage 5
        hx5 = self.stage5(hx)
        hx = self.pool56(hx5)

        #stage 6
        hx6 = self.stage6(hx)
        hx6up = _upsample_like(hx6,hx5)

        #decoder
        hx5d = self.stage5d(torch.cat((hx6up,hx5),1))
        hx5dup = _upsample_like(hx5d,hx4)

        hx4d = self.stage4d(torch.cat((hx5dup,hx4),1))
        hx4dup = _upsample_like(hx4d,hx3)

        hx3d = self.stage3d(torch.cat((hx4dup,hx3),1))
        hx3dup = _upsample_like(hx3d,hx2)

        hx2d = self.stage2d(torch.cat((hx3dup,hx2),1))
        hx2dup = _upsample_like(hx2d,hx1)

        hx1d = self.stage1d(torch.cat((hx2dup,hx1),1))


        #side output
        d1 = self.side1(hx1d)

        d2 = self.side2(hx2d)
        d2 = _upsample_like(d2,d1)

        d3 = self.side3(hx3d)
        d3 = _upsample_like(d3,d1)

        d4 = self.side4(hx4d)
        d4 = _upsample_like(d4,d1)

        d5 = self.side5(hx5d)
        d5 = _upsample_like(d5,d1)

        d6 = self.side6(hx6)
        d6 = _upsample_like(d6,d1)

        d0 = self.outconv(torch.cat((d1,d2,d3,d4,d5,d6),1))

        return F.sigmoid(d0), F.sigmoid(d1), F.sigmoid(d2), F.sigmoid(d3), F.sigmoid(d4), F.sigmoid(d5), F.sigmoid(d6)

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

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

相关文章

Android Studio编写xml布局不提示控件的部分属性问题的解决

Android Studio编写xml布局不提示控件的部分属性问题的解决

最近突然发现Android Studio编写xml，发现有一部分控件的属性没有了代码提示，主要体现为id,margin等属性不再有代码提示，如下图。 但是手动输入仍然有效。然后删掉Android Sdk重新回来还是发现有问题，导一个之前的旧项目进来&#…
阅读更多...
Mysql技术文档--慢mysql的优化--工作流--按步排查

Mysql技术文档--慢mysql的优化--工作流--按步排查

这里是用来发现慢sql的一个好方法 --by.阿丹 Prometheus-监控Mysql进阶用法(1)（安装配置）_一单成的博客-CSDN博客 阿丹： 知道了慢sql的语句那么就开始按照优化步骤对sql进行排查和优化。 1、阅读sql逻辑 首先观察sql语句的书写&#xff0…
阅读更多...
智慧邮政：浅述视频监控与AI智能分析技术助力邮政物流智能监管

智慧邮政：浅述视频监控与AI智能分析技术助力邮政物流智能监管

随着电子商务的蓬勃发展，我国的快递业务量也随之增长，邮政快递业的规模也在不断扩大。快递业务的迅猛发展促进了快递网点数量的爆发式增长，同时也带来了成本投入增加、服务质量下降等各种管理问题。快递企业每年因快递损毁、丢件等事件造成的…
阅读更多...
棉花叶病害数据集

棉花叶病害数据集

Bacterial Blight（细菌性枯萎病）：细菌性枯萎病是由细菌引起的棉花疾病，主要受害部位是棉花的叶子和茎。这种病害可以导致叶片枯萎、变色和腐烂，对棉花产量产生不利影响。 Curl Virus（卷叶病毒）…
阅读更多...
对比表：阿里云轻量应用服务器和服务器性能差异

对比表：阿里云轻量应用服务器和服务器性能差异

阿里云服务器ECS和轻量应用服务器有什么区别？轻量和ECS优缺点对比，云服务器ECS是明星级云产品，适合企业专业级的使用场景，轻量应用服务器是在ECS的基础上推出的轻量级云服务器，适合个人开发者单机应用访问量不高的网站…
阅读更多...
TF坐标变换

TF坐标变换

ROS小乌龟跟随 5.1 TF坐标变换 Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 tf模块：在 ROS 中用于实现不同坐标系之间的点或向量的转换。 在ROS中坐标变换最初对应的是tf，不过在 hydro 版本开始, tf 被弃用，迁移到 tf2,后者更…
阅读更多...
Flv.js编译使用

Flv.js编译使用

Flv.js （https://github.com/bilibili/flv.js）是 HTML5 Flash 视频（FLV）播放器，纯原生 JavaScript 开发，没有用到 Flash。由 bilibili 网站开源。本文讲述其编译使用。 Flv.js目前最新版本是v1.6.2。在htt…
阅读更多...
《视觉 SLAM 十四讲》V2 第 5 讲 相机与图像

《视觉 SLAM 十四讲》V2 第 5 讲 相机与图像

文章目录 相机 内参 && 外参5.1.2 畸变模型单目相机的成像过程5.1.3 双目相机模型5.1.4 RGB-D 相机模型 实践5.3.1 OpenCV 基础操作 【Code】OpenCV版本查看 5.3.2 图像去畸变 【Code】5.4.1 双目视觉 视差图 点云 【Code】5.4.2 RGB-D 点云 拼合成 地图【Code】 习题题…
阅读更多...
美妆护肤品商城小程序的作用是什么？

美妆护肤品商城小程序的作用是什么？

化妆品几乎可以覆盖所有人群，各式各样的品牌及经销商非常多，主要销售模式为门店零售、线上入驻电商平台售卖、批发等，近些年随着电商发展迭代以及消费升级，对品牌或经销商来说，传统经营模式变得低效，每个人…
阅读更多...
华为云云耀云服务器L实例评测｜Uniapp开发部署茶叶商城小程序、H5

华为云云耀云服务器L实例评测｜Uniapp开发部署茶叶商城小程序、H5

1、华为云云耀云服务器L实例评测｜Uniapp开发茶叶商城小程序、H5 华为云耀云服务器L实例是新一代开箱即用、面向中小企业和开发者打造的全新轻量应用云服务器。多种产品规格，满足您对成本、性能及技术创新的诉求。云耀云服务器L实例提供丰富严选的应用镜像…
阅读更多...
Spring Security 6.1.x 系列 （1）—— 初识Spring Security

Spring Security 6.1.x 系列 （1）—— 初识Spring Security

一、 Spring Security 概述 Spring Security是Spring组织提供的一个开源安全框架，基于Spring开发，所以非常适合在Spring Boot中使用。 官方文档地址：https://docs.spring.io/spring-security/reference/index.html GitHub地址：…
阅读更多...
抖音小店怎么运营？运营全流程，不懂的快来看！

抖音小店怎么运营？运营全流程，不懂的快来看！

我是电商珠珠 抖音小店是抖音旗下的电商平台，对于抖音来说流量是充足的，所以很多人想要在抖音小店上下功夫。 但是关于抖音小店的流程很多人还不太熟悉，今天我就来给大家详细的讲一下。 一、入驻准备 在入驻的时候，需要办理一…
阅读更多...
lv7 嵌入式开发-网络编程开发 09 UDP通信

lv7 嵌入式开发-网络编程开发 09 UDP通信

目录 1 用到的相关API 1.1 write/read到send/recv 1.2 sendto与recvfrom 2 UDP通信的实现过程 3 服务端代码、客户端、makefile代码实现 1 用到的相关API 1.1 write/read到send/recv send函数原型： ssize_t send(int sockfd, const void *buf, size_t len, …
阅读更多...
Ubuntu MySQL

Ubuntu MySQL

在安装前，首先看你之前是否安装过，如果安装过，但是没成功，就要先卸载。 一、卸载 1.查看安装 dpkg --list | grep mysql 有东西，就说明您之前安装过mysql。 2.卸载 先停掉server sudo systemctl stop mysql.servic…
阅读更多...
基于回溯搜索优化的BP神经网络（分类应用） - 附代码

基于回溯搜索优化的BP神经网络（分类应用） - 附代码

基于回溯搜索优化的BP神经网络（分类应用） - 附代码 文章目录 基于回溯搜索优化的BP神经网络（分类应用） - 附代码1.鸢尾花iris数据介绍2.数据集整理3.回溯搜索优化BP神经网络3.1 BP神经网络参数设置3.2 回溯搜索算法应用 4.测试结果…
阅读更多...
基于Java的飞机航班订票购票管理系统设计与实现(源码+lw+部署文档+讲解等)

基于Java的飞机航班订票购票管理系统设计与实现(源码+lw+部署文档+讲解等)

文章目录 前言具体实现截图论文参考详细视频演示为什么选择我自己的网站自己的小程序（小蔡coding）有保障的售后福利 代码参考源码获取 前言 💗博主介绍：✌全网粉丝10W,CSDN特邀作者、博客专家、CSDN新星计划导师、全栈领域优质创作…
阅读更多...
使用appscan定时批量扫描方法

使用appscan定时批量扫描方法

文章目录 一、批量扫描设置二、定时扫描设置 一、批量扫描设置 appscan的窗口模式中允许用户一次只能选择一个扫描目标，但是如果想批量扫描多个网站的时候可以通过appscan安装文件夹下的AppScanCMD.exe工具来操作，具体操作如下。 首先按常规操作添加2个…
阅读更多...
2.2.2搭建交叉编译器

2.2.2搭建交叉编译器

1 交叉编译器 交叉编译的存在，有2个原因，1个是不同的平台，架构不同，使用的指令集不同，ARM和MIPS的CPU无法运行X86指令休编码的程序，1个是一般arm平台上的存储/性能有限，无法提供一个可靠的编译环境。所以就出现了在x86上编译，在arm上运行的镜像，即交叉编译。在交叉编…
阅读更多...
git 同时配置 gitee github

git 同时配置 gitee github

git 同时配置 gitee github 1、 删除C:\Users\dell\.ssh目录。 在任意目录右击——》Git Bash Here，打开Git Bash窗口，下方命令在Git Bash窗口输入。 2、添加git全局范围的用户名和邮箱 git config --global user.email "609612189qq.com" …
阅读更多...
【Spring篇】简述IoC入门案例，DI入门案例

【Spring篇】简述IoC入门案例，DI入门案例

🎊专栏【Spring】 🍔喜欢的诗句：天行健，君子以自强不息。 🎆音乐分享【如愿】 🎄欢迎并且感谢大家指出小吉的问题🥰 文章目录 🎄Spring Framework系统架构🎆Spring核心概…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023