Sigma

已于 2024-07-29 22:07:55 修改
阅读量334 收藏 3
点赞数 3
文章标签： 深度学习 python 人工智能
于 2024-07-28 19:23:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ganchuanl/article/details/140754954
版权

Traceback (most recent call last):
  File "/home/gcl/project/CSCA-main/train.py", line 80, in <module>
    trainer.train()
  File "/home/gcl/project/CSCA-main/utils/regression_trainer.py", line 139, in train
    self.train_eopch()
  File "/home/gcl/project/CSCA-main/utils/regression_trainer.py", line 166, in train_eopch
    outputs = self.model(inputs, self.dataset)
  File "/home/gcl/anaconda3/envs/vmamba/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1190, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/gcl/project/CSCA-main/models/builder.py", line 155, in forward
    out = self.encode_decode(inputs)
  File "/home/gcl/project/CSCA-main/models/builder.py", line 135, in encode_decode
    x = self.backbone(rgb, modal_x)
  File "/home/gcl/anaconda3/envs/vmamba/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1190, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/gcl/project/CSCA-main/models/encoders/dual_vmamba.py", line 110, in forward
    out = self.forward_features(x_rgb, x_e)
  File "/home/gcl/project/CSCA-main/models/encoders/dual_vmamba.py", line 100, in forward_features
    cross_rgb, cross_x = self.cross_mamba[i](out_rgb.permute(0, 2, 3, 1).contiguous(), out_x.permute(0, 2, 3, 1).contiguous()) # B x H x W x C
  File "/home/gcl/anaconda3/envs/vmamba/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1190, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/gcl/project/CSCA-main/models/encoders/vmamba.py", line 1870, in forward
    return self._forward(x_rgb, x_e)
  File "/home/gcl/project/CSCA-main/models/encoders/vmamba.py", line 1858, in _forward
    x_rgb_cross, x_e_cross = self.op(x_rgb, x_e)
  File "/home/gcl/anaconda3/envs/vmamba/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1190, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/gcl/project/CSCA-main/models/encoders/vmamba.py", line 1633, in forward
    y_rgb, y_e = self.CMA_ssm(x_rgb_conv, x_e_conv)
  File "/home/gcl/anaconda3/envs/vmamba/lib/python3.10/site-packages/torch/nn/modules/module.py", line 1190, in _call_impl
    return forward_call(*input, **kwargs)
  File "/home/gcl/project/CSCA-main/models/encoders/vmamba.py", line 1509, in forward
    selective_scan = selective_scan_fn_v1
NameError: name 'selective_scan_fn_v1' is not defined. Did you mean: 'selective_scan'?

class EncoderDecoder(nn.Module):
    def __init__(self, args, criterion=nn.CrossEntropyLoss(reduction='mean', ignore_index=255), norm_layer=nn.BatchNorm2d):
        super(EncoderDecoder, self).__init__()
        self.channels = [64, 128, 320, 512]
        self.norm_layer = norm_layer
        # import backbone and decoder
        if args.backbone == 'swin_s':
            logger.info('Using backbone: Swin-Transformer-small')
            from .encoders.dual_swin import swin_s as backbone
            self.channels = [96, 192, 384, 768]
            self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'swin_b':
        #     logger.info('Using backbone: Swin-Transformer-Base')
        #     from .encoders.dual_swin import swin_b as backbone
        #     self.channels = [128, 256, 512, 1024]
        #     self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'mit_b5':
        #     logger.info('Using backbone: Segformer-B5')
        #     from .encoders.dual_segformer import mit_b5 as backbone
        #     self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'mit_b4':
        #     logger.info('Using backbone: Segformer-B4')
        #     from .encoders.dual_segformer import mit_b4 as backbone
        #     self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'mit_b2':
        #     logger.info('Using backbone: Segformer-B2')
        #     from .encoders.dual_segformer import mit_b2 as backbone
        #     self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'mit_b1':
        #     logger.info('Using backbone: Segformer-B1')
        #     from .encoders.dual_segformer import mit_b0 as backbone
        #     self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'mit_b0':
        #     logger.info('Using backbone: Segformer-B0')
        #     self.channels = [32, 64, 160, 256]
        #     from .encoders.dual_segformer import mit_b0 as backbone
        #     self.backbone = backbone(norm_fuse=norm_layer)
        # elif cfg.backbone == 'mamba':
        #     logger.info('Using backbone: MAMBA')
        #     from .encoders.dual_vmamba_sub_attn import mit_b2 as backbone
        #     self.backbone = backbone(norm_fuse=norm_layer)
        elif args.backbone == 'sigma_tiny':
            logger.info('Using backbone: V-MAMBA')
            self.channels = [96, 192, 384, 768]
            from .encoders.dual_vmamba import vssm_tiny as backbone
            self.backbone = backbone()
        elif args.backbone == 'sigma_small':
            logger.info('Using backbone: V-MAMBA')
            self.channels = [96, 192, 384, 768]
            from .encoders.dual_vmamba import vssm_small as backbone
            self.backbone = backbone()
        elif args.backbone == 'sigma_base':
            logger.info('Using backbone: V-MAMBA')
            self.channels = [128, 256, 512, 1024]
            from .encoders.dual_vmamba import vssm_base as backbone
            self.backbone = backbone()
        else:
            logger.info('Using backbone: Segformer-B2')
            from .encoders.dual_segformer import mit_b2 as backbone
            self.backbone = backbone(norm_fuse=norm_layer)

        self.aux_head = None

        if args.decoder == 'MLPDecoder':
            logger.info('Using MLP Decoder')
            from .decoders.MLPDecoder import DecoderHead
            self.decode_head = DecoderHead(in_channels=self.channels, num_classes=args.num_classes, norm_layer=norm_layer, embed_dim=args.decoder_embed_dim)
        
        # elif cfg.decoder == 'UPernet':
        #     logger.info('Using Upernet Decoder')
        #     from .decoders.UPernet import UPerHead
        #     self.decode_head = UPerHead(in_channels=self.channels ,num_classes=cfg.num_classes, norm_layer=norm_layer, channels=512)
        #     from .decoders.fcnhead import FCNHead
        #     self.aux_index = 2
        #     self.aux_rate = 0.4
        #     self.aux_head = FCNHead(self.channels[2], cfg.num_classes, norm_layer=norm_layer)
        #
        # elif cfg.decoder == 'deeplabv3+':
        #     logger.info('Using Decoder: DeepLabV3+')
        #     from .decoders.deeplabv3plus import DeepLabV3Plus as Head
        #     self.decode_head = Head(in_channels=self.channels, num_classes=cfg.num_classes, norm_layer=norm_layer)
        #     from .decoders.fcnhead import FCNHead
        #     self.aux_index = 2
        #     self.aux_rate = 0.4
        #     self.aux_head = FCNHead(self.channels[2], cfg.num_classes, norm_layer=norm_layer)
        #
        elif args.decoder == 'MambaDecoder':
            logger.info('Using Mamba Decoder')
            from .decoders.MambaDecoder import MambaDecoder
            self.deep_supervision = False
            self.decode_head = MambaDecoder(img_size=[args.image_height, args.image_width], in_channels=self.channels, num_classes=args.num_classes, embed_dim=self.channels[0], deep_supervision=self.deep_supervision)

        else:
            logger.info('No decoder(FCN-32s)')
            from .decoders.fcnhead import FCNHead
            self.decode_head = FCNHead(in_channels=self.channels[-1], kernel_size=3, num_classes=args.num_classes, norm_layer=norm_layer)

        self.criterion = criterion
        if self.criterion:
            self.init_weights(args, pretrained=args.pretrained_model)
    
    def init_weights(self, cfg, pretrained=None):
        if pretrained:
            if cfg.backbone != 'vmamba':
                logger.info('Loading pretrained model: {}'.format(pretrained))
                self.backbone.init_weights(pretrained=pretrained)
        logger.info('Initing weights ...')
        init_weight(self.decode_head, nn.init.kaiming_normal_,
                self.norm_layer, cfg.bn_eps, cfg.bn_momentum,
                mode='fan_in', nonlinearity='relu')
        if self.aux_head:
            init_weight(self.aux_head, nn.init.kaiming_normal_,
                self.norm_layer, cfg.bn_eps, cfg.bn_momentum,
                mode='fan_in', nonlinearity='relu')

    def encode_decode(self, inputs):
        """Encode images with backbone and decode into a semantic segmentation
        map of the same size as input."""
        rgb = inputs[0]
        modal_x = inputs[1]
        if not self.deep_supervision:
            orisize = rgb.shape
            x = self.backbone(rgb, modal_x)
            out = self.decode_head.forward(x)
            out = F.interpolate(out, size=orisize[2:], mode='bilinear', align_corners=False)
            if self.aux_head:
                aux_fm = self.aux_head(x[self.aux_index])
                aux_fm = F.interpolate(aux_fm, size=orisize[2:], mode='bilinear', align_corners=False)
                return out, aux_fm
            return out
        else:
            x = self.backbone(rgb, modal_x)
            x_last, x_output_0, x_output_1, x_output_2 = self.decode_head.forward(x)
            return x_last, x_output_0, x_output_1, x_output_2

    def forward(self, inputs, label=None):
        # rgb = inputs[0]
        # modal_x = inputs[1]
        if not self.deep_supervision:
            if self.aux_head:
                out, aux_fm = self.encode_decode(inputs)
            else:
                out = self.encode_decode(inputs)
            # if label is not None:
            #     loss = self.criterion(out, label.long())
            #     if self.aux_head:
            #         loss += self.aux_rate * self.criterion(aux_fm, label.long())
            #     return loss
            return out

class FCNHead(nn.Module):
    def __init__(self, in_channels=384, channels=None, kernel_size=3, dilation=1,
                 num_classes=40, norm_layer=nn.BatchNorm2d):
        super(FCNHead, self).__init__()
        self.kernel_size = kernel_size
        self.in_channels = in_channels
        self.channels = channels or in_channels // 4

        conv_padding = (kernel_size // 2) * dilation
        self.conv = nn.Sequential(
                nn.Conv2d(self.in_channels, self.channels, kernel_size, padding=conv_padding),
                norm_layer(self.channels),
                nn.ReLU(inplace=True)
                )

        self.classifier = nn.Conv2d(self.channels, 1, kernel_size=1)

    def forward(self, x):
        output = self.conv(x)
        output = self.classifier(output)
        return output

import torch
import torch.nn as nn
import torch.nn.functional as F

class MambaDecoder(nn.Module):
    def __init__(self, 
                 img_size=[480, 640],
                 in_channels=[96, 192, 384, 768],
                 num_classes=1,
                 dropout_ratio=0.1,
                 embed_dim=96,
                 align_corners=False,
                 patch_size=4, 
                 depths=[4, 4, 4, 4], 
                 mlp_ratio=4.,
                 drop_rate=0.0,
                 attn_drop_rate=0.,
                 drop_path_rate=0.1,
                 norm_layer=nn.LayerNorm,
                 use_checkpoint=False,
                 deep_supervision=False,
                 **kwargs):
        super().__init__()

        self.num_classes = num_classes
        self.num_layers = len(depths)
        self.mlp_ratio = mlp_ratio
        self.patch_size = patch_size
        self.patches_resolution = [img_size[0] // patch_size, img_size[1] // patch_size]
        self.deep_supervision = deep_supervision

        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]

        self.layers_up = nn.ModuleList()
        for i_layer in range(self.num_layers):
            if i_layer == 0:
                layer_up = PatchExpand(
                    input_resolution=(self.patches_resolution[0] // (2 ** (self.num_layers - 1 - i_layer)),
                                      self.patches_resolution[1] // (2 ** (self.num_layers - 1 - i_layer))),
                    dim=int(embed_dim * 2 ** (self.num_layers - 1 - i_layer)), 
                    dim_scale=2, 
                    norm_layer=norm_layer)
            else:
                layer_up = Mamba_up(dim=int(embed_dim * 2 ** (self.num_layers - 1 - i_layer)),
                                    input_resolution=(self.patches_resolution[0] // (2 ** (self.num_layers - 1 - i_layer)),
                                                      self.patches_resolution[1] // (2 ** (self.num_layers - 1 - i_layer))),
                                    depth=depths[(self.num_layers - 1 - i_layer)],
                                    mlp_ratio=self.mlp_ratio,
                                    drop=drop_rate, 
                                    attn_drop=attn_drop_rate,
                                    drop_path=dpr[sum(depths[:(self.num_layers - 1 - i_layer)]):sum(depths[:(self.num_layers - 1 - i_layer) + 1])],
                                    norm_layer=norm_layer,
                                    upsample=PatchExpand if (i_layer < self.num_layers - 1) else None,
                                    use_checkpoint=use_checkpoint)
            self.layers_up.append(layer_up)

        self.norm_up = norm_layer(embed_dim)
        if self.deep_supervision:
            self.norm_ds = nn.ModuleList([norm_layer(embed_dim * 2 ** (self.num_layers - 2 - i_layer)) for i_layer in range(self.num_layers-1)])
            self.output_ds = nn.ModuleList([nn.Conv2d(in_channels=embed_dim * 2 ** (self.num_layers - 2 - i_layer), out_channels=self.num_classes, kernel_size=1, bias=False) for i_layer in range(self.num_layers-1)])

        # 调整特征图大小的卷积层
        self.reduce_conv = nn.Conv2d(in_channels=embed_dim, out_channels=embed_dim, kernel_size=3, stride=2, padding=1, bias=False)
        self.output = nn.Conv2d(in_channels=embed_dim, out_channels=self.num_classes, kernel_size=1, bias=False)

    def forward_up_features(self, inputs):
        if not self.deep_supervision:
            for inx, layer_up in enumerate(self.layers_up):
                if inx == 0:
                    x = inputs[3 - inx]  # B, 768, 8, 8
                    x = x.permute(0, 2, 3, 1).contiguous()  # B, 8, 8, 768
                    y = layer_up(x)  # B, 16, 16, 384
                else:
                    B, C, H, W = inputs[3 - inx].shape
                    y = F.interpolate(y.permute(0, 3, 1, 2).contiguous(), size=(H, W), mode='bilinear', align_corners=False).permute(0, 2, 3, 1).contiguous()
                    x = y + inputs[3 - inx].permute(0, 2, 3, 1).contiguous()
                    y = layer_up(x)

            x = self.norm_up(y)
            return x
        else:
            x_upsample = []
            for inx, layer_up in enumerate(self.layers_up):
                if inx == 0:
                    x = inputs[3 - inx]  # B, 768, 8, 8
                    x = x.permute(0, 2, 3, 1).contiguous()  # B, 8, 8, 768
                    y = layer_up(x)  # B, 16, 16, 384
                    x_upsample.append(self.norm_ds[inx](y))
                else:
                    x = y + inputs[3 - inx].permute(0, 2, 3, 1).contiguous()
                    y = layer_up(x)
                    if inx != self.num_layers - 1:
                        x_upsample.append(self.norm_ds[inx](y))

            x = self.norm_up(y)
            return x, x_upsample
    
    def forward(self, inputs):
        if not self.deep_supervision:
            x = self.forward_up_features(inputs)  # B, H, W, C
            x = x.permute(0, 3, 1, 2).contiguous()  # B, C, H, W
            x = self.reduce_conv(x)  # 使用卷积层调整特征图大小
            x = self.output(x)  # 调整通道数为1
            return x
        else:
            x, x_upsample = self.forward_up_features(inputs)
            x_last = x.permute(0, 3, 1, 2).contiguous()  # B, C, H, W
            x_last = self.reduce_conv(x_last)  # 使用卷积层调整特征图大小
            x_last = self.output(x_last)  # 调整通道数为1
            x_output_0 = self.output_ds[0](F.interpolate(x_upsample[0].permute(0,3,1,2).contiguous(), scale_factor=16, mode='bilinear', align_corners=False))
            x_output_1 = self.output_ds[1](F.interpolate(x_upsample[1].permute(0,3,1,2).contiguous(), scale_factor=8, mode='bilinear', align_corners=False))
            x_output_2 = self.output_ds[2](F.interpolate(x_upsample[2].permute(0,3,1,2).contiguous(), scale_factor=4, mode='bilinear', align_corners=False))
            return x_last, x_output_0, x_output_1, x_output_2

Traceback (most recent call last):
  File "/home/gcl/project/CSCA-main/train.py", line 79, in <module>
    trainer.setup()
  File "/home/gcl/project/CSCA-main/utils/regression_trainer.py", line 98, in setup
    self.model = segmodel(args, criterion=criterion, norm_layer=BatchNorm2d)
  File "/home/gcl/project/CSCA-main/models/builder.py", line 62, in __init__
    from .encoders.dual_vmamba import vssm_small as backbone
  File "/home/gcl/project/CSCA-main/models/encoders/dual_vmamba.py", line 12, in <module>
    from models.encoders.vmamba import Backbone_VSSM, CrossMambaFusionBlock, ConcatMambaFusionBlock
  File "/home/gcl/project/CSCA-main/models/encoders/vmamba.py", line 32, in <module>
    import selective_scan_cuda_core as selective_scan_cuda
ImportError: /home/gcl/anaconda3/envs/vmunet/lib/python3.10/site-packages/selective_scan_cuda_core.cpython-310-x86_64-linux-gnu.so: undefined symbol: _ZN3c104cuda9SetDeviceEi


 

ganchuanl
关注
Sigma-Delta 调制
baidu_34971492的博客
07-30 4349
将delta调制器修改为sigma-delta调制器可以解决上述问题。 Sigma-Delta 调制 (SDM) 的开发始于 1960 年代，以克服 delta 模拟的局限性。 Sigma-delta 系统量化当前 sigma 与先前差值的 sigma（总和）之间的 delta（D，差值）（它是一个闭环反馈系统）。积分器放置在量化器的输入端；信号幅度在变化的频率下是恒定的（类似于频率调制，FM）。因此SDM也被称为脉冲密度调制器（PDM，相当于PWD）。与 PCM 一样，SDM 直接量化信号，而不是像增量调
sigma delta与LMS
dongdaxiaobai的博客
07-09 670
sigma_delta基础
ultra sigma 软件
qq_59223724的博客
08-24 943
下载示波器截软件ultra sigma打不开 有什么办法吗？
sigma-delta ADC原理
热门推荐
Fantasy237的博客
04-03 2万+
主要是想大致了解Sigma-delta ADC是怎么工作的，写了个乱七八糟的代码来简单看下。很粗略的解释，主要给自己参考。 SAR ADC successive approximation register adc，简单理解为一个采样开关和采样电容。采样开关定时闭合，忽略暂态，则采样电容上的电压等于采样开关闭合时刻的输入电压。 因此理想的SAR ADC相当于一个采样开关 ，把连续的输入信号变成了离散的采样结果。 或者，另一种画图的方法，就是说，[n*Ts,(n+1)*Ts]期间的采样结果恒定为Vin(n
sigma delta调制器
努力学习的IC小白
05-15 2089
为了介绍SD转换器的概念，让我们从sigma调制器开始，如图所示，其中量化器采样的误差信号是输入信号和反馈信号之间的差或增量。反馈信号是输出的积分。因此，如果Vx
Sigma algebra
qq_36890813的博客
10-10 1810
1.什么样的东西叫做Sigma algebra 这里全集记作S，Sigma algebra是S一族子集合。 它有三个限制条件，Sigma algebra记作σ，σ中的一个子集记作e （1）空集∈σ （2）e∈σ，则e的补集∈σ （3）e1,e2,e3,…∈σ，则∪,从 i = 1开始，i = ∞截至，ei的并运算的结果属于σ，公式张这个样子 2.举个例子 一个骰子扔出去的所有可能性组成一个全集S。...
什么是sigma，计算公式是什么？举个例
学无止尽，谨言慎行！
12-27 5306
Sigma是希腊字母Σ的名称，在数学中表示求和。当我们需要对一组数进行求和时，可以使用sigma符号。Σ表示求和符号，n表示求和的上限，i表示求和的变量，Ai表示每个变量的值。
高等概率论——域和sigma域
weixin_55914136的博客
04-23 1867
是奇数集，包含所有的奇数，也是可数无限的，所以。中有一个是有限的，一个是无限的。是可数无限集，包括所有的偶数，且。
基于FPGA的sigma delta ADC软件无线电设计
FPGA/MATLAB学习教程/源码/项目合作开发
03-07 2161
输入频域因为是AM信号，所以在5K~2M HZ之间，ADC的精度要求不限，能满足一般音频处理即可（满足演示要求，建议采样64MHZ上限，8位）此部分设计需要用到FPGA开发板上的2个LVDS输入端口。第二部分输入为第一部分的数字输出信号，进行一般的软件无线电设计即可。按照一般收音机的设计，将硬件全部由软件（FPGA）来替代。收音机的挑台旋转按钮可用开发板上的开关来设计。这里，我们主要基于DE0开发板进行设计，下面首先分析一下DE0开发板。上升沿有效,频率为开发板的晶振。表一、顶层模块接口定义。
Sigma Function
而濡木染
03-20 1725
Sigma Function ：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=109329#problem/C 密码：nefu 题目大意：已知Sigma函数表示的是该数的所有因子的和，要求出从1到n，Sigma函数的值为偶数的数的个数。 PC-大致分析：由于n比较大，从1到n遍历肯定会超时，而且对于每一个i都要进行判断其Sigma函
Sigma5_sigma5_minecraftsigma5_
10-02
《Sigma5：深入探索Minecraft中的游戏增强工具》 在Minecraft这个充满无限可能的沙盒游戏中，玩家总是追求更丰富的游戏体验。 Sigma5，一个专门为Minecraft设计的作弊文件，正是为了满足这一需求而诞生的。这个工具...
sigma-z.rar_36W_Sigma_sigma z 坐标_sigma坐标_垂直坐标相互转换程序
07-14
标题中的"sigma-z.rar_36W_Sigma_sigma z 坐标_sigma坐标_垂直坐标相互转换程序"指的是一个关于水文学或海洋学中的坐标转换软件包，它主要用于处理36000米（36W）深度范围内的Sigma坐标与Z坐标之间的转换。...
sigma.zip_Sigma_Sigma滤波_sigma 滤波_西格玛滤波
07-15
标题"sigma.zip_Sigma_Sigma滤波_sigma 滤波_西格玛滤波"提到了“sigma”、“滤波”以及“西格玛滤波”等关键词，暗示了该压缩包内容可能是一个关于信号处理或图像处理的MATLAB程序，具体是实现西格玛滤波（Sigma ...
sigma-rules:自定义sigma规则的集合
03-26
西格玛规则（Sigma Rules）是一种用于安全事件检测和威胁狩猎的开源规则集，它主要应用于日志分析工具，如Elasticsearch、Splunk、Logstash等。这些规则可以帮助安全分析师识别网络中的异常行为，从而及时发现潜在的...
sigma:LVPP sigma配置文件数据库+ COSMO-SAC参数设置
05-10
LVPP sigma配置文件数据库+ COSMO-SAC参数设置 这是用于基于COSMO的模型的LVPP sigma-profile数据库。 它目前包含有关1700多个分子以及。 对于COSMO-SAC参数设置，请检查文件夹。 当前，在此存储库中，我们仅提供...
深度学习中常见的损失函数
hallo128的博客
09-09 344
损失函数是衡量神经网络输出与真实标签之间差距的指标。在训练过程中，神经网络的目标是最小化损失函数的值。常见的损失函数包括均方误差（MSE）损失函数、交叉熵（Cross-Entropy）损失函数等。损失函数的选择取决于任务的需求和输出数据的类型。这些损失函数各有特点，适用于不同的场景和问题。在实际应用中，需要根据具体任务和数据集的特点来选择合适的损失函数。
【人工智能学习笔记】4_3 深度学习基础之循环神经网络
最新发布
RIKI_1
09-10 1244
是一类以序列（sequence）数据为输入，在序列的演进方向进行递归（recursion）且所有节点（循环单元）按链式连接的递归神经网络（recursive neural network），循环神经网络具有短期记忆能力。
基于深度学习的自动化产品设计
weixin_42605076的博客
09-07 807
基于深度学习的自动化产品设计通过结合生成模型、强化学习和仿真技术，实现了产品设计流程的高效化和智能化。这种方法为工业、建筑、时尚等多个领域带来了创新的可能性，同时也面临着数据、效率和信任度等方面的挑战。随着深度学习技术的不断发展和成熟，自动化产品设计将在更多领域中发挥重要作用，并促进更智能、更创新的设计实践。
基于深度学习的结构优化与生成
weixin_42605076的博客
09-07 1372
基于深度学习的结构优化与生成技术通过自动生成和优化结构设计，为工程和工业应用带来了巨大的潜力。随着算法的不断改进和计算资源的增加，深度学习有望在未来推动结构设计的革命性变化，带来更高效、更创新的设计流程。
latex sigma
07-19
在 LaTeX 中，`\sigma` 是一个预定义的希腊字母，表示希腊小写字母 "&sigma;"，通常用于数学符号，例如标准偏差或求和符号。要直接在文档中输入 `\sigma`，不需要额外的宏或包。 如果你想要一个上下标形式的 &sigma;，如求和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值