精华内容
下载资源
问答
  • 检查了一下 报错的代码是plot(m,x0,'*',m,yuce,'r') 的后部分,可是m和yuce的长度是一样的呀,都是52,每个年份都有其对应的预测值的,还望高手赐教! x0=[60.2,61.5,62.8,64.6,66,67.2,66.2,65.9,67.3,69.1,...
  • 所有代码只能在CPU上运行(将参数--cpu设置为true)。 数据生成只能在CPU上完成。 可以在CPU上进行模型训练和模型评估,但是训练将非常慢。 要使用GPU进行训练或评估,您需要启用CUDA的GPU(即NVIDIA芯片)。 我们...
  • pytorch项目代码总结

    2020-08-02 15:46:01
    model.cuda().half()就可以实现对模型所有参数进行精度浮点型设置 精度浮点型模型如果是通过adam优化器训练得到的,可能会出现某些权重为NAN的情况,sgd没有这个问题 精度浮点型模型在大型网络训练时,速度较...
    1. 半精度浮点型
    • 如果想生成半精度浮点型训练模型,则在训练的过程中,模型和输入样本数据都要cuda().half()进行处理
    • model.cuda().half()就可以实现对模型所有参数进行半精度浮点型设置
    • 半精度浮点型模型如果是通过adam优化器训练得到的,可能会出现某些权重为NAN的情况,sgd没有这个问题
    • 半精度浮点型模型在大型网络训练时,速度较于全精度快很多,但对于小模型速度提升不明显
    展开全文
  • squeezenet代码解读

    2021-01-14 11:01:44
    目录概述使用了1 x 1卷积,方便灵活改变通道数、减少参数量通过squeeze layer较少了通道数将池化层放在比较靠后的位置,使得前部分的特征信息尽可能不被遗忘。网络结构图Fire模块朴素版本、加上跳跃连接、1 x 1...

    squeezenet代码解读

    概述

    squeezenet是一款轻量级的CNN,它的参数量相当于AlexNet参数量的1/50(经过减枝、稀疏化等模型压缩手段过后,可以进一步较少为AlexNet参数量的1/500),但是却在ImageNet上取得了相当的分类效果。
    squeezenet在网络结构上主要做了如下创新:

    使用了1 x 1卷积,方便灵活改变通道数、减少参数量

    通过squeeze layer较少了通道数

    将池化层放在比较靠后的位置,使得前半部分的特征信息尽可能不被遗忘。

    网络结构图

    Fire模块

    在这里插入图片描述

    朴素版本、加上跳跃连接、1 x 1卷积的squeezenet

    在这里插入图片描述

    每一层输入输出的tensor变化

    每一层的tensor的输出shape

    输入size为3 x 224 x 224的tensor,squeezenet1_0版本每一层的输出为:

    if __name__ == "__main__":
        model = SqueezeNet()
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        t = model.to(device)
        summary(t,(3,224,224))
    #output tensor shape in each layer
    ----------------------------------------------------------------
            Layer (type)               Output Shape         Param #
    ================================================================
                Conv2d-1         [-1, 96, 109, 109]          14,208
                  ReLU-2         [-1, 96, 109, 109]               0
             MaxPool2d-3           [-1, 96, 54, 54]               0
                Conv2d-4           [-1, 16, 54, 54]           1,552
                  ReLU-5           [-1, 16, 54, 54]               0
                Conv2d-6           [-1, 64, 54, 54]           1,088
                  ReLU-7           [-1, 64, 54, 54]               0
                Conv2d-8           [-1, 64, 54, 54]           9,280
                  ReLU-9           [-1, 64, 54, 54]               0
                 Fire-10          [-1, 128, 54, 54]               0
               Conv2d-11           [-1, 16, 54, 54]           2,064
                 ReLU-12           [-1, 16, 54, 54]               0
               Conv2d-13           [-1, 64, 54, 54]           1,088
                 ReLU-14           [-1, 64, 54, 54]               0
               Conv2d-15           [-1, 64, 54, 54]           9,280
                 ReLU-16           [-1, 64, 54, 54]               0
                 Fire-17          [-1, 128, 54, 54]               0
               Conv2d-18           [-1, 32, 54, 54]           4,128
                 ReLU-19           [-1, 32, 54, 54]               0
               Conv2d-20          [-1, 128, 54, 54]           4,224
                 ReLU-21          [-1, 128, 54, 54]               0
               Conv2d-22          [-1, 128, 54, 54]          36,992
                 ReLU-23          [-1, 128, 54, 54]               0
                 Fire-24          [-1, 256, 54, 54]               0
            MaxPool2d-25          [-1, 256, 27, 27]               0
               Conv2d-26           [-1, 32, 27, 27]           8,224
                 ReLU-27           [-1, 32, 27, 27]               0
               Conv2d-28          [-1, 128, 27, 27]           4,224
                 ReLU-29          [-1, 128, 27, 27]               0
               Conv2d-30          [-1, 128, 27, 27]          36,992
                 ReLU-31          [-1, 128, 27, 27]               0
                 Fire-32          [-1, 256, 27, 27]               0
               Conv2d-33           [-1, 48, 27, 27]          12,336
                 ReLU-34           [-1, 48, 27, 27]               0
               Conv2d-35          [-1, 192, 27, 27]           9,408
                 ReLU-36          [-1, 192, 27, 27]               0
               Conv2d-37          [-1, 192, 27, 27]          83,136
                 ReLU-38          [-1, 192, 27, 27]               0
                 Fire-39          [-1, 384, 27, 27]               0
               Conv2d-40           [-1, 48, 27, 27]          18,480
                 ReLU-41           [-1, 48, 27, 27]               0
               Conv2d-42          [-1, 192, 27, 27]           9,408
                 ReLU-43          [-1, 192, 27, 27]               0
               Conv2d-44          [-1, 192, 27, 27]          83,136
                 ReLU-45          [-1, 192, 27, 27]               0
                 Fire-46          [-1, 384, 27, 27]               0
               Conv2d-47           [-1, 64, 27, 27]          24,640
                 ReLU-48           [-1, 64, 27, 27]               0
               Conv2d-49          [-1, 256, 27, 27]          16,640
                 ReLU-50          [-1, 256, 27, 27]               0
               Conv2d-51          [-1, 256, 27, 27]         147,712
                 ReLU-52          [-1, 256, 27, 27]               0
                 Fire-53          [-1, 512, 27, 27]               0
            MaxPool2d-54          [-1, 512, 13, 13]               0
               Conv2d-55           [-1, 64, 13, 13]          32,832
                 ReLU-56           [-1, 64, 13, 13]               0
               Conv2d-57          [-1, 256, 13, 13]          16,640
                 ReLU-58          [-1, 256, 13, 13]               0
               Conv2d-59          [-1, 256, 13, 13]         147,712
                 ReLU-60          [-1, 256, 13, 13]               0
                 Fire-61          [-1, 512, 13, 13]               0
              Dropout-62          [-1, 512, 13, 13]               0
               Conv2d-63         [-1, 1000, 13, 13]         513,000
                 ReLU-64         [-1, 1000, 13, 13]               0
    AdaptiveAvgPool2d-65           [-1, 1000, 1, 1]               0
    ================================================================
    Total params: 1,248,424
    Trainable params: 1,248,424
    Non-trainable params: 0
    ----------------------------------------------------------------
    Input size (MB): 0.57
    Forward/backward pass size (MB): 91.80
    Params size (MB): 4.76
    Estimated Total Size (MB): 97.14
    ----------------------------------------------------------------
    

    如果将size为3 x 224 x 224的tensor送入squeezenet1_1,则输出为:

    if __name__ == "__main__":
        model = SqueezeNet('1_1')
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        t = model.to(device)
        summary(t,(3,224,224))
    # output tensor shape in each layer
    ----------------------------------------------------------------
            Layer (type)               Output Shape         Param #
    ================================================================
                Conv2d-1         [-1, 64, 111, 111]           1,792
                  ReLU-2         [-1, 64, 111, 111]               0
             MaxPool2d-3           [-1, 64, 55, 55]               0
                Conv2d-4           [-1, 16, 55, 55]           1,040
                  ReLU-5           [-1, 16, 55, 55]               0
                Conv2d-6           [-1, 64, 55, 55]           1,088
                  ReLU-7           [-1, 64, 55, 55]               0
                Conv2d-8           [-1, 64, 55, 55]           9,280
                  ReLU-9           [-1, 64, 55, 55]               0
                 Fire-10          [-1, 128, 55, 55]               0
               Conv2d-11           [-1, 16, 55, 55]           2,064
                 ReLU-12           [-1, 16, 55, 55]               0
               Conv2d-13           [-1, 64, 55, 55]           1,088
                 ReLU-14           [-1, 64, 55, 55]               0
               Conv2d-15           [-1, 64, 55, 55]           9,280
                 ReLU-16           [-1, 64, 55, 55]               0
                 Fire-17          [-1, 128, 55, 55]               0
            MaxPool2d-18          [-1, 128, 27, 27]               0
               Conv2d-19           [-1, 32, 27, 27]           4,128
                 ReLU-20           [-1, 32, 27, 27]               0
               Conv2d-21          [-1, 128, 27, 27]           4,224
                 ReLU-22          [-1, 128, 27, 27]               0
               Conv2d-23          [-1, 128, 27, 27]          36,992
                 ReLU-24          [-1, 128, 27, 27]               0
                 Fire-25          [-1, 256, 27, 27]               0
               Conv2d-26           [-1, 32, 27, 27]           8,224
                 ReLU-27           [-1, 32, 27, 27]               0
               Conv2d-28          [-1, 128, 27, 27]           4,224
                 ReLU-29          [-1, 128, 27, 27]               0
               Conv2d-30          [-1, 128, 27, 27]          36,992
                 ReLU-31          [-1, 128, 27, 27]               0
                 Fire-32          [-1, 256, 27, 27]               0
            MaxPool2d-33          [-1, 256, 13, 13]               0
               Conv2d-34           [-1, 48, 13, 13]          12,336
                 ReLU-35           [-1, 48, 13, 13]               0
               Conv2d-36          [-1, 192, 13, 13]           9,408
                 ReLU-37          [-1, 192, 13, 13]               0
               Conv2d-38          [-1, 192, 13, 13]          83,136
                 ReLU-39          [-1, 192, 13, 13]               0
                 Fire-40          [-1, 384, 13, 13]               0
               Conv2d-41           [-1, 48, 13, 13]          18,480
                 ReLU-42           [-1, 48, 13, 13]               0
               Conv2d-43          [-1, 192, 13, 13]           9,408
                 ReLU-44          [-1, 192, 13, 13]               0
               Conv2d-45          [-1, 192, 13, 13]          83,136
                 ReLU-46          [-1, 192, 13, 13]               0
                 Fire-47          [-1, 384, 13, 13]               0
               Conv2d-48           [-1, 64, 13, 13]          24,640
                 ReLU-49           [-1, 64, 13, 13]               0
               Conv2d-50          [-1, 256, 13, 13]          16,640
                 ReLU-51          [-1, 256, 13, 13]               0
               Conv2d-52          [-1, 256, 13, 13]         147,712
                 ReLU-53          [-1, 256, 13, 13]               0
                 Fire-54          [-1, 512, 13, 13]               0
               Conv2d-55           [-1, 64, 13, 13]          32,832
                 ReLU-56           [-1, 64, 13, 13]               0
               Conv2d-57          [-1, 256, 13, 13]          16,640
                 ReLU-58          [-1, 256, 13, 13]               0
               Conv2d-59          [-1, 256, 13, 13]         147,712
                 ReLU-60          [-1, 256, 13, 13]               0
                 Fire-61          [-1, 512, 13, 13]               0
              Dropout-62          [-1, 512, 13, 13]               0
               Conv2d-63         [-1, 1000, 13, 13]         513,000
                 ReLU-64         [-1, 1000, 13, 13]               0
    AdaptiveAvgPool2d-65           [-1, 1000, 1, 1]               0
    ================================================================
    Total params: 1,235,496
    Trainable params: 1,235,496
    Non-trainable params: 0
    ----------------------------------------------------------------
    Input size (MB): 0.57
    Forward/backward pass size (MB): 53.76
    Params size (MB): 4.71
    Estimated Total Size (MB): 59.05
    ----------------------------------------------------------------
    

    squeezenet代码细节分析

    import torch
    import torch.nn as nn
    import torch.nn.init as init
    from .utils import load_state_dict_from_url
    from typing import Any
    import numpy as np
    from torchsummary import summary
    # 可供选择的squeezenet模型
    __all__ = ['SqueezeNet','squeezenet1_0','squeezenet1_1']
    # 预训练权重下载链接
    model_urls = {
        'squeezenet1_0': 'https://download.pytorch.org/models/squeezenet1_0-a815701f.pth',
        'squeezenet1_1': 'https://download.pytorch.org/models/squeezenet1_1-f364aa15.pth',
    }
    
    class Fire(nn.Module):
    
        def __init__(
            self,
            inplanes: int,
            squeeze_planes: int,
            expand1x1_planes: int,
            expand3x3_planes: int
        ) -> None:
            super(Fire, self).__init__()
            self.inplanes = inplanes
            self.squeeze = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1)
            self.squeeze_activation = nn.ReLU(inplace=True)
            self.expand1x1 = nn.Conv2d(squeeze_planes, expand1x1_planes,kernel_size=1)
            self.expand1x1_activation = nn.ReLU(inplace=True)
            self.expand3x3 = nn.Conv2d(squeeze_planes, expand3x3_planes,kernel_size=3, padding=1)
            self.expand3x3_activation = nn.ReLU(inplace=True)
        # Fire结构
        def forward(self,x):
            # 卷积、激活、concat
            x = self.squeeze_activation(self.squeeze(x))
            # expand1x1和expand3x3两者相同,也就是说通道数相同,可以直接concat起来
            return torch.cat([
                self.expand1x1_activation(self.expand1x1(x)),
                self.expand3x3_activation(self.expand3x3(x))
            ], 1)
    
    
    class SqueezeNet(nn.Module):
    
        def __init__(
            self,
            version: str = '1_0',
            num_classes: int = 1000
        ) -> None:
            super(SqueezeNet, self).__init__()
            self.num_classes = num_classes
            # 两个不同版本的特征分类器
            if version == '1_0':
                self.features = nn.Sequential(
                    nn.Conv2d(3, 96, kernel_size=7, stride=2),
                    nn.ReLU(inplace=True),
                    nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                    Fire(96, 16, 64, 64),
                    Fire(128, 16, 64, 64),
                    Fire(128, 32, 128, 128),
                    nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                    Fire(256, 32, 128, 128),
                    Fire(256, 48, 192, 192),
                    Fire(384, 48, 192, 192),
                    Fire(384, 64, 256, 256),
                    nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                    Fire(512, 64, 256, 256),
                )
            elif version == '1_1':
                self.features = nn.Sequential(
                    nn.Conv2d(3, 64, kernel_size=3, stride=2),
                    nn.ReLU(inplace=True),
                    nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                    Fire(64, 16, 64, 64),
                    Fire(128, 16, 64, 64),
                    nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                    Fire(128, 32, 128, 128),
                    Fire(256, 32, 128, 128),
                    nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
                    Fire(256, 48, 192, 192),
                    Fire(384, 48, 192, 192),
                    Fire(384, 64, 256, 256),
                    Fire(512, 64, 256, 256),
                )
            else:
                # FIXME: Is this needed? SqueezeNet should only be called from the
                # FIXME: squeezenet1_x() functions
                # FIXME: This checking is not done for the other models
                raise ValueError("Unsupported SqueezeNet version {version}:"
                                "1_0 or 1_1 expected".format(version=version))
    
            # Final convolution is initialized differently from the rest
            # 最后一个卷积层的初始化跟其他的卷积层不一样
            final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
            # 分类器
            self.classifier = nn.Sequential(
                nn.Dropout(p=0.5),
                final_conv,
                nn.ReLU(inplace=True),
                nn.AdaptiveAvgPool2d((1, 1))
            )
            # 不同层的参数初始化方法
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    if m is final_conv:
                        init.normal_(m.weight, mean=0.0, std=0.01)
                    else:
                        init.kaiming_uniform_(m.weight)
                    if m.bias is not None:
                        init.constant_(m.bias, 0)
        # 特征提取器、分类器
        def forward(self, x: torch.Tensor) -> torch.Tensor:
            x = self.features(x)
            x = self.classifier(x)
            # 下面这行命令也可以写成return x.view(x.size(0),self.num_classes)
            return torch.flatten(x, 1)
    
    
    def _squeezenet(version: str, pretrained: bool, progress: bool, **kwargs: Any) -> SqueezeNet:
        model = SqueezeNet(version, **kwargs)
        if pretrained:
            arch = 'squeezenet' + version
            # 加载预训练权重
            state_dict = load_state_dict_from_url(model_urls[arch],progress=progress)
            model.load_state_dict(state_dict)
        return model
    
    
    def squeezenet1_0(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> SqueezeNet:
        r"""SqueezeNet model architecture from the `"SqueezeNet: AlexNet-level
        accuracy with 50x fewer parameters and <0.5MB model size"
        <https://arxiv.org/abs/1602.07360>`_ paper.
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _squeezenet('1_0', pretrained, progress, **kwargs)
    
    
    def squeezenet1_1(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> SqueezeNet:
        r"""SqueezeNet 1.1 model from the `official SqueezeNet repo
        <https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1>`_.
        SqueezeNet 1.1 has 2.4x less computation and slightly fewer parameters
        than SqueezeNet 1.0, without sacrificing accuracy.
        Args:
            pretrained (bool): If True, returns a model pre-trained on ImageNet
            progress (bool): If True, displays a progress bar of the download to stderr
        """
        return _squeezenet('1_1', pretrained, progress, **kwargs)
    
    if __name__ == "__main__":
        model = SqueezeNet('1_1')
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        t = model.to(device)
        summary(t,(3,224,224))
    
    展开全文
  • 使用方法很简单,菜单功能都可以通过下面按钮实现,首先设置好参数后,通过按钮【STL文件】打开ast模型文件,执行【模型分层】和【生产CLI】后,通过【选择模型】动态演示需要的模型,或使用其它按钮设置模型状态
  • 材质编辑器上只有一个选项: 通过代码修改的话,需要知道那几个选项对应的渲染参数。unity的着色器扩展资源里是有Standard着色器的材质球GUI代码的,可以直接参考...例如改为透明模式的代码如下,基本上直接拷过

    材质编辑器上只有一个选项:


    通过代码修改的话,需要知道那几个选项对应的渲染参数。unity的着色器扩展资源里是有Standard着色器的材质球GUI代码的,可以直接参考这里:

    动态改变StandardShader的RenderingMode让模型透明

    知道这些了就很好办了,注意除了switch-case里的代码外,还要设置_Modle参数。例如改为半透明模式的代码如下,基本上直接拷过来就行:

    Material m = new Material(Shader.Find("Standard"));
    m.SetFloat("_Mode", 3);
    m.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
    m.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
    m.SetInt("_ZWrite", 0);
    m.DisableKeyword("_ALPHATEST_ON");
    m.EnableKeyword("_ALPHABLEND_ON");
    m.DisableKeyword("_ALPHAPREMULTIPLY_ON");
    m.renderQueue = 3000;




    展开全文
  • 1.1.22 题目里有这样一句话:...对于后句话我认为应该是随着递归的深度加深, 每次打印参数前的空白缩进需要加长。 下面是代码: import edu.princeton.cs.algs4.*; public class Main { public static vo

    1.1.22

    题目里有这样一句话:“打印出它的参数lo和hi并按照递归的深度缩进”

    我的理解:首先明确每调用一次递归就打印一次lo和hi,

    对于后半句话我认为应该是随着递归的深度加深,

    每次打印参数前的空白缩进需要加长。

    下面是代码:

    import edu.princeton.cs.algs4.*;
    public class Main {
    
        public static void main(String[] args) {
            int [] test = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
            int location =  rank(9,test);
            System.out.print("The key is located in " + location);
    
        }//close main
    
        public static int rank(int key, int [] a){
            int count = 0;
            return rank(key, a, 0, a.length,count);
        }//method binary search
        public static int rank(int key, int[] a, int lo, int hi, int count){
            int mid = (int) (hi + lo) /2;
            count++;
            for (int i = 0;i < count-1; i++) System.out.print(" ");
            System.out.println("lo: "+lo+" hi: "+hi);
            if(lo > hi) return -1;
            if(a[mid] < key) return rank(key,a,mid,hi,count);
            if(a[mid] > key) return rank(key,a,lo,mid,count);
            return mid;
        }
    }

    输出:

    lo: 0 hi: 11
     lo: 5 hi: 11
      lo: 8 hi: 11
    The key is located in 9

    解析:

    按照题目的提示(为递归方法添加一个参数来保存递归的深度),所以我为递归方法添加了整型变量count,每次调用都加1。

    然后将count用于打印参数前进行空白打印。



    展开全文
  • java代码规范&数据库设计规范

    千次阅读 2017-11-15 14:09:15
    i)禁止使用英文、拼音 i)类名:类名使用UpperCamelCase; i)方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格,必须遵从驼峰形式。 i)领域模型结尾: DO / DTO / VO 等 i)枚举以...
  • :针对传统实物仿真中的一些问题,提出一种新的面向VxWorks的实物仿真平台。设计了标准化、多接I=I、可扩展的仿真计算 机硬件架构,解决了硬件I/O接口的...及实时模型参数修改和仿真数据采集等进行了研究和实现。
  • Mixed Precision Training ... 我们介绍了使用精度浮点数训练深度神经网络的方法,而不会损失模型的准确性或无需修改超参数。 这几乎将内存需求减少了一半,并且在最近的GPU上,加快了运算速度。 权重...
  • 凯撒加密解密程序 1个目标文件 1、程序结构化,用函数分别实现 2、对文件的加密,解密输出到文件 利用随机函数抽取幸运数字 简单 EJB的真实世界模型(源代码) 15个目标文件 摘要:Java源码,初学实例,基于EJB的真实...
  • 2、一种监督的自适应肤色分割算法,对原有模型参数进行监督的在线调整 但是都没有 具体的实现代码,我也不知道怎么去实现它。 不知道直接采用直方图反向投影出来的效果怎么样? 有木有大佬了解的呀!!...
  • 实现(自动化),即通过参数控制是否需要静态化页面(哪里我说错了,勿喷!谢谢)  1,请求.do的URL时直接生成对应的.htm文件,并将请求转发到该htm文件  2,自由控制某个页面是否需要静态化 如果看图不懂的呢,...
  • 第一生成模型: 在生成模型之中我们要关注生成器输入的参数的形状是什么,中间参数的shape怎么变化的,以及生成器输出的形状是什么   第二识别模型:同样在识别器中,我们要关注识别器中输入的参数有哪些,中间...
  • 在前部分,我们已经完成了前两大步,并决定使用ResNet50预训练网络来训练模型。那么接下来,就让我们引入keras中已经封装好的ResNet50预训练网络参数。 ResNet50的引入 代码实现 base_model = ResNet50...
  • 联合弱和监督深度学习对乳房超声图像中肿块的定位和分类 这是 。 这基于Faster R-CNN 的Tensorflow实现,在建议的通用框架中将其用作质量检测器... 使用适当的输入参数(包括下载的模型的路径)运行$ROOT/code/main/
  • 在低资源环境中,尽管参数少99.9%,但PET和iPET明显优于常规监督训练,各种监督基线甚至GPT-3。 PET的迭代变体(iPET)可以训练多代模型,甚至可以在没有任何训练数据的情况下使用。 #例子 训练模式 Yelp...
  • 上例中吃发生误纠,如下代码关闭字粒度纠错: import pycorrector error_sentence_1 = '我的喉咙发炎了要买点阿莫细林吃' pycorrector.enable_char_error(enable=False) correct_sent = pycorrector.correct(error_...
  • 部和底部 中断共享 中断驱动的I/O 快速参考 第十一章 内核的数据类型 使用标准C语言类型 为数据项分配确定的空间大小 接口特定的类型 其他有关移植性的问题 链表 快速参考 第十二章 PCI驱动程序 ...
  • 演示效果共享参数参数块的使用。 5、FragmentLinker 演示段落的使用。 第21章 HLSL高级应用 1、HLSLSelfShadowing 演示使用HLSL渲染语言进行GPU编程实现自遮蔽阴影。 2、HLSLBumpTexture 演示使用HLSL渲染语言...
  • 8.4.3 琐碎计划/自动参数化 347 8.4.4 限制 348 8.4.5 备注——有效地探索多项计划 349 8.5 统计信息、基数估计和开销 350 8.5.1 统计信息设计 351 8.5.2 密度/频度信息 353 8.5.3 筛选的统计信息 355...
  • Pyrallel(Parallel Data Analytics in Python)基于分布式计算模式的机器学习和交互式的试验项目,可在小型集群上运行,适用范围: l focus on small to medium dataset that fits in memory on a small (10+ ...
  • 10.4.4 CONNECT_BY_ISCYCLE伪列和NOCYCLE参数 284 10.4.5 CONNECT_BY_ISLEAF伪列 287 10.5 小结 291 第11章 联结和反联结 292 11.1 联结 292 11.2 联结执行计划 300 11.3 控制联结执行计划 305 ...
  • 8.4.3 琐碎计划/自动参数化 347 8.4.4 限制 348 8.4.5 备注——有效地探索多项计划 349 8.5 统计信息、基数估计和开销 350 8.5.1 统计信息设计 351 8.5.2 密度/频度信息 353 8.5.3 筛选的统计信息 355...
  • 其采取的步骤是首先训练一个较大的模型,之后使用剪枝算法检出那些不重要的参数,之后再在重要参数的基础上进行finetune,以期望恢复网络性能。这篇文章对剪枝的后段进行思考, 是否真的需要在重要权重的基础上...
  • Jeecg-Boot低代码开发平台,可以应用在任何J2EE项目的开发中,尤其适合SAAS项目、企业信息管理系统(MIS)、内部办公系统(OA)、企业资源计划系统(ERP)、客户关系管理系统(CRM)等,其智能手工Merge的开发方式...
  • 深度学习matlab源码

    2016-01-27 20:24:29
    本资源是深度学习autoencoder模型基于matlab的实现代码,该模型部分是数据编码(即数据的降维过程),后部分是解码(即原始数据的恢复过程,用来计算重构误差),在网络初始化阶段采用RBM,参数调优过程采用的...
  • BiCens_Fam_Genorisk-源码

    2021-03-22 01:48:17
    这是“阿尔茨海默氏病家族研究中双变量删减事件的半参数回归分析”的C ++代码。 BiCens_Fam.h包括所提出的双变量回归分析方法的主要计算代码。 BiCens_Fam_T.h包括用于单变量回归分析的计算代码。 BiCens_Fam_...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 157
精华内容 62
关键字:

代码半参数模型