EGE-UNet:一种有效的组增强UNet皮肤病变分割方法

最新推荐文章于 2024-03-31 09:16:59 发布
最新推荐文章于 2024-03-31 09:16:59 发布
阅读量1.2k 收藏 4
点赞数 1
分类专栏： 分割 文章标签： 人工智能 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45745941/article/details/132015735
版权

文章目录

EGE-UNet: an Efficient Group Enhanced UNet for skin lesion segmentation

摘要

Transformer及其变体在医学图像分割中有着广泛的应用。然而，这些模型的大量参数和计算量使其不适合移动医疗应用。为了解决这个问题，我们提出了一种更有效的方法，即高效增强UNet (EGE-UNet)。我们以轻量级的方式集成了一个组的多轴Hadamard注意力模块(GHPA)和一个组聚合桥接模块(GAB)。GHPA对输入特征进行分组，并在不同轴上执行Hadamard注意机制(HPA)，从不同角度提取病理信息。GAB通过分组低阶特征、高阶特征和解码器在每个阶段生成的掩码，有效地融合了多尺度信息。
在ISIC2017和ISIC2018数据集上的综合实验表明，EGEUNet优于现有的最先进的方法。简而言之，与TransFuse相比，我们的模型实现了卓越的分割性能，同时将参数和计算成本分别降低了494倍和160倍。此外，据我们所知，这是第一个参数计数限制为50KB的模型。
代码地址
在这里插入图片描述

本文方法

在这里插入图片描述
整体模型比较简单，看看主要的GHPA和GAB

GHPA

在这里插入图片描述
为了克服MHSA的二次复杂度问题，我们提出了具有线性复杂度的HPA。
给定一个输入x和一个随机初始化的可学习张量p，首先利用双线性插值来调整p的大小以匹配x的大小。
然后，我们对p使用深度可分离卷积(DW)，然后在x和p之间进行标准积运算以获得输出。
然而，单纯使用简单的HPA不足以从多个角度提取信息，结果并不理想。
受MHSA中的多头模式的启发，我们引入了基于HPA的GHPA，如算法1所示。

沿着通道维度将输入平均分为四组，并分别对前三组的高度-宽度、通道-高度和通道-宽度轴执行HPA。对于最后一组，我们只在特征映射上使用DW。最后，我们沿着通道维度将四组连接起来，并应用另一个DW从不同角度整合信息。注意，DW中使用的所有内核大小都是3。

GAB

在这里插入图片描述

多尺度信息的获取被认为是密集预测任务的关键，如医学图像分割。因此，如图3所示，我们引入GAB，它接受三个输入:低级特征、高级特征和掩码。首先，利用深度可分卷积(deep -分离式convolution, DW)和双线性插值来调整高阶特征的大小，从而匹配低阶特征的大小;其次，沿着通道维度将两个特征映射划分为四组，并将一组低级特征与一组高级特征连接起来，得到四组融合特征;

损失函数是联合多级特征

网络代码

import torch
from torch import nn
import torch.nn.functional as F
from einops import rearrange

from timm.models.layers import trunc_normal_
import math


class DepthWiseConv2d(nn.Module):
    def __init__(self, dim_in, dim_out, kernel_size=3, padding=1, stride=1, dilation=1):
        super().__init__()
        
        self.conv1 = nn.Conv2d(dim_in, dim_in, kernel_size=kernel_size, padding=padding, 
                      stride=stride, dilation=dilation, groups=dim_in)
        self.norm_layer = nn.GroupNorm(4, dim_in)
        self.conv2 = nn.Conv2d(dim_in, dim_out, kernel_size=1)

    def forward(self, x):
        return self.conv2(self.norm_layer(self.conv1(x)))


class LayerNorm(nn.Module):
    r""" From ConvNeXt (https://arxiv.org/pdf/2201.03545.pdf)
    """
    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(normalized_shape))
        self.bias = nn.Parameter(torch.zeros(normalized_shape))
        self.eps = eps
        self.data_format = data_format
        if self.data_format not in ["channels_last", "channels_first"]:
            raise NotImplementedError 
        self.normalized_shape = (normalized_shape, )
    
    def forward(self, x):
        if self.data_format == "channels_last":
            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
        elif self.data_format == "channels_first":
            u = x.mean(1, keepdim=True)
            s = (x - u).pow(2).mean(1, keepdim=True)
            x = (x - u) / torch.sqrt(s + self.eps)
            x = self.weight[:, None, None] * x + self.bias[:, None, None]
            return x
    

class group_aggregation_bridge(nn.Module):
    def __init__(self, dim_xh, dim_xl, k_size=3, d_list=[1,2,5,7]):
        super().__init__()
        self.pre_project = nn.Conv2d(dim_xh, dim_xl, 1)
        group_size = dim_xl // 2
        self.g0 = nn.Sequential(
            LayerNorm(normalized_shape=group_size+1, data_format='channels_first'),
            nn.Conv2d(group_size + 1, group_size + 1, kernel_size=3, stride=1, 
                      padding=(k_size+(k_size-1)*(d_list[0]-1))//2, 
                      dilation=d_list[0], groups=group_size + 1)
        )
        self.g1 = nn.Sequential(
            LayerNorm(normalized_shape=group_size+1, data_format='channels_first'),
            nn.Conv2d(group_size + 1, group_size + 1, kernel_size=3, stride=1, 
                      padding=(k_size+(k_size-1)*(d_list[1]-1))//2, 
                      dilation=d_list[1], groups=group_size + 1)
        )
        self.g2 = nn.Sequential(
            LayerNorm(normalized_shape=group_size+1, data_format='channels_first'),
            nn.Conv2d(group_size + 1, group_size + 1, kernel_size=3, stride=1, 
                      padding=(k_size+(k_size-1)*(d_list[2]-1))//2, 
                      dilation=d_list[2], groups=group_size + 1)
        )
        self.g3 = nn.Sequential(
            LayerNorm(normalized_shape=group_size+1, data_format='channels_first'),
            nn.Conv2d(group_size + 1, group_size + 1, kernel_size=3, stride=1, 
                      padding=(k_size+(k_size-1)*(d_list[3]-1))//2, 
                      dilation=d_list[3], groups=group_size + 1)
        )
        self.tail_conv = nn.Sequential(
            LayerNorm(normalized_shape=dim_xl * 2 + 4, data_format='channels_first'),
            nn.Conv2d(dim_xl * 2 + 4, dim_xl, 1)
        )
    def forward(self, xh, xl, mask):
        xh = self.pre_project(xh)
        xh = F.interpolate(xh, size=[xl.size(2), xl.size(3)], mode ='bilinear', align_corners=True)
        xh = torch.chunk(xh, 4, dim=1)
        xl = torch.chunk(xl, 4, dim=1)
        x0 = self.g0(torch.cat((xh[0], xl[0], mask), dim=1))
        x1 = self.g1(torch.cat((xh[1], xl[1], mask), dim=1))
        x2 = self.g2(torch.cat((xh[2], xl[2], mask), dim=1))
        x3 = self.g3(torch.cat((xh[3], xl[3], mask), dim=1))
        x = torch.cat((x0,x1,x2,x3), dim=1)
        x = self.tail_conv(x)
        return x


class Grouped_multi_axis_Hadamard_Product_Attention(nn.Module):
    def __init__(self, dim_in, dim_out, x=8, y=8):
        super().__init__()
        
        c_dim_in = dim_in//4
        k_size=3
        pad=(k_size-1) // 2
        
        self.params_xy = nn.Parameter(torch.Tensor(1, c_dim_in, x, y), requires_grad=True)
        nn.init.ones_(self.params_xy)
        self.conv_xy = nn.Sequential(nn.Conv2d(c_dim_in, c_dim_in, kernel_size=k_size, padding=pad, groups=c_dim_in), nn.GELU(), nn.Conv2d(c_dim_in, c_dim_in, 1))

        self.params_zx = nn.Parameter(torch.Tensor(1, 1, c_dim_in, x), requires_grad=True)
        nn.init.ones_(self.params_zx)
        self.conv_zx = nn.Sequential(nn.Conv1d(c_dim_in, c_dim_in, kernel_size=k_size, padding=pad, groups=c_dim_in), nn.GELU(), nn.Conv1d(c_dim_in, c_dim_in, 1))

        self.params_zy = nn.Parameter(torch.Tensor(1, 1, c_dim_in, y), requires_grad=True)
        nn.init.ones_(self.params_zy)
        self.conv_zy = nn.Sequential(nn.Conv1d(c_dim_in, c_dim_in, kernel_size=k_size, padding=pad, groups=c_dim_in), nn.GELU(), nn.Conv1d(c_dim_in, c_dim_in, 1))

        self.dw = nn.Sequential(
                nn.Conv2d(c_dim_in, c_dim_in, 1),
                nn.GELU(),
                nn.Conv2d(c_dim_in, c_dim_in, kernel_size=3, padding=1, groups=c_dim_in)
        )
        
        self.norm1 = LayerNorm(dim_in, eps=1e-6, data_format='channels_first')
        self.norm2 = LayerNorm(dim_in, eps=1e-6, data_format='channels_first')
        
        self.ldw = nn.Sequential(
                nn.Conv2d(dim_in, dim_in, kernel_size=3, padding=1, groups=dim_in),
                nn.GELU(),
                nn.Conv2d(dim_in, dim_out, 1),
        )
        
    def forward(self, x):
        x = self.norm1(x)
        x1, x2, x3, x4 = torch.chunk(x, 4, dim=1)
        B, C, H, W = x1.size()
        #----------xy----------#
        params_xy = self.params_xy
        x1 = x1 * self.conv_xy(F.interpolate(params_xy, size=x1.shape[2:4],mode='bilinear', align_corners=True))
        #----------zx----------#
        x2 = x2.permute(0, 3, 1, 2)
        params_zx = self.params_zx
        x2 = x2 * self.conv_zx(F.interpolate(params_zx, size=x2.shape[2:4],mode='bilinear', align_corners=True).squeeze(0)).unsqueeze(0)
        x2 = x2.permute(0, 2, 3, 1)
        #----------zy----------#
        x3 = x3.permute(0, 2, 1, 3)
        params_zy = self.params_zy
        x3 = x3 * self.conv_zy(F.interpolate(params_zy, size=x3.shape[2:4],mode='bilinear', align_corners=True).squeeze(0)).unsqueeze(0)
        x3 = x3.permute(0, 2, 1, 3)
        #----------dw----------#
        x4 = self.dw(x4)
        #----------concat----------#
        x = torch.cat([x1,x2,x3,x4],dim=1)
        #----------ldw----------#
        x = self.norm2(x)
        x = self.ldw(x)
        return x



    
    

class EGEUNet(nn.Module):
    
    def __init__(self, num_classes=1, input_channels=3, c_list=[8,16,24,32,48,64], bridge=True, gt_ds=True):
        super().__init__()

        self.bridge = bridge
        self.gt_ds = gt_ds
        
        self.encoder1 = nn.Sequential(
            nn.Conv2d(input_channels, c_list[0], 3, stride=1, padding=1),
        )
        self.encoder2 =nn.Sequential(
            nn.Conv2d(c_list[0], c_list[1], 3, stride=1, padding=1),
        ) 
        self.encoder3 = nn.Sequential(
            nn.Conv2d(c_list[1], c_list[2], 3, stride=1, padding=1),
        )
        self.encoder4 = nn.Sequential(
            Grouped_multi_axis_Hadamard_Product_Attention(c_list[2], c_list[3]),
        )
        self.encoder5 = nn.Sequential(
            Grouped_multi_axis_Hadamard_Product_Attention(c_list[3], c_list[4]),
        )
        self.encoder6 = nn.Sequential(
            Grouped_multi_axis_Hadamard_Product_Attention(c_list[4], c_list[5]),
        )

        if bridge: 
            self.GAB1 = group_aggregation_bridge(c_list[1], c_list[0])
            self.GAB2 = group_aggregation_bridge(c_list[2], c_list[1])
            self.GAB3 = group_aggregation_bridge(c_list[3], c_list[2])
            self.GAB4 = group_aggregation_bridge(c_list[4], c_list[3])
            self.GAB5 = group_aggregation_bridge(c_list[5], c_list[4])
            print('group_aggregation_bridge was used')
        if gt_ds:
            self.gt_conv1 = nn.Sequential(nn.Conv2d(c_list[4], 1, 1))
            self.gt_conv2 = nn.Sequential(nn.Conv2d(c_list[3], 1, 1))
            self.gt_conv3 = nn.Sequential(nn.Conv2d(c_list[2], 1, 1))
            self.gt_conv4 = nn.Sequential(nn.Conv2d(c_list[1], 1, 1))
            self.gt_conv5 = nn.Sequential(nn.Conv2d(c_list[0], 1, 1))
            print('gt deep supervision was used')
        
        self.decoder1 = nn.Sequential(
            Grouped_multi_axis_Hadamard_Product_Attention(c_list[5], c_list[4]),
        ) 
        self.decoder2 = nn.Sequential(
            Grouped_multi_axis_Hadamard_Product_Attention(c_list[4], c_list[3]),
        ) 
        self.decoder3 = nn.Sequential(
            Grouped_multi_axis_Hadamard_Product_Attention(c_list[3], c_list[2]),
        )  
        self.decoder4 = nn.Sequential(
            nn.Conv2d(c_list[2], c_list[1], 3, stride=1, padding=1),
        )  
        self.decoder5 = nn.Sequential(
            nn.Conv2d(c_list[1], c_list[0], 3, stride=1, padding=1),
        )  
        self.ebn1 = nn.GroupNorm(4, c_list[0])
        self.ebn2 = nn.GroupNorm(4, c_list[1])
        self.ebn3 = nn.GroupNorm(4, c_list[2])
        self.ebn4 = nn.GroupNorm(4, c_list[3])
        self.ebn5 = nn.GroupNorm(4, c_list[4])
        self.dbn1 = nn.GroupNorm(4, c_list[4])
        self.dbn2 = nn.GroupNorm(4, c_list[3])
        self.dbn3 = nn.GroupNorm(4, c_list[2])
        self.dbn4 = nn.GroupNorm(4, c_list[1])
        self.dbn5 = nn.GroupNorm(4, c_list[0])

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

        self.apply(self._init_weights)

    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            trunc_normal_(m.weight, std=.02)
            if isinstance(m, nn.Linear) and m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.Conv1d):
                n = m.kernel_size[0] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
        elif isinstance(m, nn.Conv2d):
            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
            fan_out //= m.groups
            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
            if m.bias is not None:
                m.bias.data.zero_()

    def forward(self, x):
        
        out = F.gelu(F.max_pool2d(self.ebn1(self.encoder1(x)),2,2))
        t1 = out # b, c0, H/2, W/2

        out = F.gelu(F.max_pool2d(self.ebn2(self.encoder2(out)),2,2))
        t2 = out # b, c1, H/4, W/4 

        out = F.gelu(F.max_pool2d(self.ebn3(self.encoder3(out)),2,2))
        t3 = out # b, c2, H/8, W/8
        
        out = F.gelu(F.max_pool2d(self.ebn4(self.encoder4(out)),2,2))
        t4 = out # b, c3, H/16, W/16
        
        out = F.gelu(F.max_pool2d(self.ebn5(self.encoder5(out)),2,2))
        t5 = out # b, c4, H/32, W/32
        
        out = F.gelu(self.encoder6(out)) # b, c5, H/32, W/32
        t6 = out
        
        out5 = F.gelu(self.dbn1(self.decoder1(out))) # b, c4, H/32, W/32
        if self.gt_ds: 
            gt_pre5 = self.gt_conv1(out5)
            t5 = self.GAB5(t6, t5, gt_pre5)
            gt_pre5 = F.interpolate(gt_pre5, scale_factor=32, mode ='bilinear', align_corners=True)
        else: t5 = self.GAB5(t6, t5)
        out5 = torch.add(out5, t5) # b, c4, H/32, W/32
        
        out4 = F.gelu(F.interpolate(self.dbn2(self.decoder2(out5)),scale_factor=(2,2),mode ='bilinear',align_corners=True)) # b, c3, H/16, W/16
        if self.gt_ds: 
            gt_pre4 = self.gt_conv2(out4)
            t4 = self.GAB4(t5, t4, gt_pre4)
            gt_pre4 = F.interpolate(gt_pre4, scale_factor=16, mode ='bilinear', align_corners=True)
        else:t4 = self.GAB4(t5, t4)
        out4 = torch.add(out4, t4) # b, c3, H/16, W/16
        
        out3 = F.gelu(F.interpolate(self.dbn3(self.decoder3(out4)),scale_factor=(2,2),mode ='bilinear',align_corners=True)) # b, c2, H/8, W/8
        if self.gt_ds: 
            gt_pre3 = self.gt_conv3(out3)
            t3 = self.GAB3(t4, t3, gt_pre3)
            gt_pre3 = F.interpolate(gt_pre3, scale_factor=8, mode ='bilinear', align_corners=True)
        else: t3 = self.GAB3(t4, t3)
        out3 = torch.add(out3, t3) # b, c2, H/8, W/8
        
        out2 = F.gelu(F.interpolate(self.dbn4(self.decoder4(out3)),scale_factor=(2,2),mode ='bilinear',align_corners=True)) # b, c1, H/4, W/4
        if self.gt_ds: 
            gt_pre2 = self.gt_conv4(out2)
            t2 = self.GAB2(t3, t2, gt_pre2)
            gt_pre2 = F.interpolate(gt_pre2, scale_factor=4, mode ='bilinear', align_corners=True)
        else: t2 = self.GAB2(t3, t2)
        out2 = torch.add(out2, t2) # b, c1, H/4, W/4 
        
        out1 = F.gelu(F.interpolate(self.dbn5(self.decoder5(out2)),scale_factor=(2,2),mode ='bilinear',align_corners=True)) # b, c0, H/2, W/2
        if self.gt_ds: 
            gt_pre1 = self.gt_conv5(out1)
            t1 = self.GAB1(t2, t1, gt_pre1)
            gt_pre1 = F.interpolate(gt_pre1, scale_factor=2, mode ='bilinear', align_corners=True)
        else: t1 = self.GAB1(t2, t1)
        out1 = torch.add(out1, t1) # b, c0, H/2, W/2
        
        out0 = F.interpolate(self.final(out1),scale_factor=(2,2),mode ='bilinear',align_corners=True) # b, num_class, H, W
        
        if self.gt_ds:
            return (torch.sigmoid(gt_pre5), torch.sigmoid(gt_pre4), torch.sigmoid(gt_pre3), torch.sigmoid(gt_pre2), torch.sigmoid(gt_pre1)), torch.sigmoid(out0)
        else:
            return torch.sigmoid(out0)

实验结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

小杨小杨1
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
学习记录——SegNetr、EGE-UNet、R2AU-Net、PHNet、CFNet
Chaoy6565的博客
08-02 717
GAB。
EGE-Informatica-C4:C4 统一州考试计算机科学准备
06-16
EGE-Informatica-C4 C4 统一州考试计算机科学准备 它将在 pascal 和 python 中存储 C4 问题的解决方案。 但是为了在 C4 任务中获得 4 分，你需要从网站解决很多问题，所以最好专注于它们而不是解决一百个 C4 问题。
Unet语义分割训练和TensorRT部署
08-14
Unet语义分割训练和TensorRT部署
EGE-UNet
whaosoft143ai的博客
07-22 380
本文主要提出了两个新颖的模块，GHPA 和 GAB，这两个模块大大降低了模型的复杂性，并且提高了模型的性能。同时，本文基于这两个模块构建了EGE-UNet，用于皮肤病变分割任务，实验结果表明，该方法达到了最先进的性能，同时显著降低了资源需求。whaosoft aiot http://143ai.com 其中，GHPA利用哈达玛积注意力机制（HPA），通过将输入特征进行分组，对不同轴进行HPA操作，从多个视角提取病变信息。这种方法是受到多头自注意力机制(MHSA)的启发，而 HPA 则可以减少模型
EGE-UNet An Efficient Group Enhanced UNet for Skin Lesion Segmentation【即插即用】
最新发布
bettle_king的博客
03-31 443
及其变体在医学图像分割中有着广泛的应用。然而，这些模型的大量参数和计算量使其不适合移动医疗应用。为了解决这个问题，我们提出了一种更有效的方法，即高效组增强UNet (EGE-UNet)。我们以轻量级的方式集成了一个组多轴Hadamard产品关注模块(GHPA)和一个组聚合桥模块(GAB)。GHPA对输入特征进行分组，并在不同轴上执行Hadamard产品注意机制(HPA)，从不同角度提取病理信息。GAB通过分组低阶特征、高阶特征和解码器在每个阶段生成的掩码，有效地融合了多尺度信息。
EfficientUnet-PyTorch:以EfficientNet为编码器的Unet的PyTorch 1.0实现
05-05
高效的Unet-PyTorch 以EfficientNet为编码器的Unet的PyTorch 1.0实现 有用的笔记 由于解码器路径中存在一些舍入问题（不是错误，因此这是一个功能） :smirking_face: ），输入形状应可被32整除。 例如224x224是适合输入图像的尺寸，但225x225不适合。 要求 Python> = 3.6 > = 1.0.0 安装 安装efficientunet-pytorch ： pip install efficientunet-pytorch 用法 1.高效网 例如，说您想要具有5个类的预训练的efficiencynet-b5模型： from efficientunet import * model = EfficientNet . from_name ( 'efficientnet-b5' , n_classes = 5 , pretrained = True
助力质检维护，基于超轻量级分割模型ege-unet开发构建水泥基建裂缝分割识别系统
Together_CZ的博客
08-01 321
助力质检维护，基于超轻量级分割模型ege-unet开发构建水泥基建裂缝分割识别系统
【计算机视觉 | 图像分割】arxiv 计算机视觉关于图像分割的学术速递（7 月 18 日论文合集）
wzk4869的博客
07-22 823
【计算机视觉 | 图像分割】arxiv 计算机视觉关于图像分割的学术速递（7 月 18 日论文合集）
参数量仅有50KB的超轻量级unet变种网络egeunet【参数和计算量降低494和160倍】医疗图像分割实践
Together_CZ的博客
07-31 1429
参数量仅有50KB的超轻量级unet变种网络egeunet【参数和计算量降低494和160倍】医疗图像分割实践
【论文阅读】EGE-UNet: anEfficient Group Enhanced UNet for skin lesion segmentation
goodenough5的博客
08-01 1136
轻量级模型，参数和计算复杂度降低的同时分割精度提升。
基于Python Unet的医学影像分割系统源码，含皮肤病的数据及皮肤病分割的模型，用户输入图像，模型可以自动分割去皮肤病的区域
Python代码大全
01-06 3016
论文地址：https://arxiv.org/pdf/1505.04597.pdfU-Net原理分析与代码解读 - 知乎 (zhihu.com)Unet 发表于 2015 年，属于 FCN 的一种变体。Unet 的初衷是为了解决生物医学图像方面的问题，由于效果确实很好后来也被广泛的应用在语义分割的各个方向，比如卫星图像分割，工业瑕疵检测等。Unet 跟 FCN 都是 Encoder-Decoder 结构，结构简单但很有效。Encoder 负责特征提取，你可以将自己熟悉的各种特征提取网络放在这个位置。
Eff-Unet-keras
04-11
Eff-Unet-keras
chas-ege:免费的考试培训师
05-03
项目“统一州考试时间” 该项目的目的是帮助准备统一州考试和OGE。 执行 该项目是使用构建的静态站点 浏览器支持 仅对相对较新版本（不超过一年半）的浏览器提供支持： Chrome和Chrome基 火狐浏览器 使用说明 （最新版本） 开箱 打开index.html文件 链接 以下站点提供了已组装的项目 （已稳定发布更新） （在每个版本之后更新） 组装说明 注意：如果您不了解该项目的含义，请跳过该项目。 注意：这些说明是为Linux发行版设计的 克隆存储库 完全安装Git ， Node.js 使用npm安装grunt-cli 运行根目录： npm install 现在可以使用grunt命令进行组装 执照 该项目的源代码是在下分发的（请参阅LICENSE）。
Dikaer_p - 5.1 ege - 8LianTong - 副本.zip_C++_codeblocks_ege_八连通_种
09-25
基于ege库的八连通矩阵填充 数据结构 codeblocks 种子填充
ege-开源
05-30
ege（简易图形引擎）
EGE-tasks-by-code
03-31
通过代码进行EGE任务
EGE-UNet, 轻量化U-Net
skyfengye的博客
07-23 1518
其实一开始看到这个网络结构，我感觉有点恍惚，这都2023年了，还有人 这样魔改U-Net, 但是当我看我以后，发现了一些新的思路与方法。具体网络结构与细节，大家可以具体看看论文，我看完这篇文章的感觉，不在于模型设计的两个模块的精巧，而是看到原来还可以这样多层预测进行分割呀。通过这些高级模块的集成，EGE-UNet 在比先前的方法提升了分割性能的同时，显著减少了参数和计算负载。随着transform 的出现，现在语义分割网路结构越来越复杂，轻量化网路也较少了，有些轻量化也只是名义上的轻量化。
利用EGE库设计一个绘制多边形的程序
06-10
好的，以下是一个简单的绘制多边形的程序，使用EGE库实现： ```c #include <graphics.h> int main() { initgraph(640, 480); // 初始化图形界面 int n = 5; // 多边形边数 int x[n], y[n]; // 多边形各个顶点的坐标 // 输入多边形各个顶点的坐标 printf("Please input the coordinates of %d vertices:\n", n); for (int i = 0; i < n; ++i) { scanf("%d %d", &x[i], &y[i]); } // 绘制多边形 setcolor(YELLOW); for (int i = 0; i < n; ++i) { int j = (i + 1) % n; line(x[i], y[i], x[j], y[j]); } getch(); // 暂停程序，等待用户关闭图形界面 closegraph(); // 关闭图形界面 return 0; } ``` 在程序中，我们使用了EGE库的 `initgraph` 函数初始化了一个大小为640x480的图形界面，然后通过输入多边形各个顶点的坐标，使用 `line` 函数绘制了多边形。最后通过 `getch` 函数暂停程序，等待用户关闭图形界面并返回0结束程序。 需要注意的是，在使用EGE库之前，需要在编译器中添加EGE库的链接。具体可以参考EGE库的官方文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小杨小杨1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值