精华内容
下载资源
问答
  • EBS值集定义
    千次阅读
    2015-01-18 20:20:08

    1、表验证值集

    步骤:
    (1)进入职责应用产品员--应用产品--验证--请求集
    (2).1输入值集名,说明,列表类型:值列表,格式类型:字符,最大尺寸:输入需要的大小
    (2).2验证类型:表
    (3)点击页面“编辑信息”按钮,进入验证表信息界面:
    (编辑信息界面相当于一个select语句,表名:相当于from后的句子;多个表可以用‘,’分开,值是:select后的句子,标识:关联的条件,出处/排序依据:where子句,附加列:不需要返回但要在lov中显示的列)

    1>.添加表名;直接输入就行
    注:(1)如果表列的字段出现重复值时,我们可以利用‘(select distinct 列名 from cux_cst_lot_numbers) cln’这么一个小转换来去除重复的值;
          (2)如果所用的表有moac屏蔽时,表名前面加上应用简称和点
                  例如:hss_xds_groups表有moac屏蔽我们选择这个表时应该填hss.hss_xds_groups
    2>.在表列中的“值”中输入表中的列:这个值是显示在参数lov中的列,同时也是返回的值,不需要定义别名,自己会有别名;选择相应的类型,设置相应大小
    3>.”含义“字段中对应的是lov显示的说明段,会自动附上”说明“别名
    4>.在“标识”中添加相应的值,同样是表中的字段;一般是id,是比较的参数,相当于where的值;同样设置其类型和大小
         1.有标识时传标识,没标识时传值;
         2.标识中的列不会显示在lov中;
         3.在标识中出现的字段不能再出现在附加列中,否则会报错;
    5>.想要在lov中显示出标识的列时
    可以做如下设置:设置”值“为需要返回的值
    ”含义“为默认说明段
    ”附加列“为附加需要显示在lov中的列
    6>.出处/排序依据:在这里我们可以添加相应的屏蔽语句和排序语句
       1.如果是where子句时需要在前面添上‘where’关键字
       2.如果需要根据之前的一个参数来屏蔽现有参数时,只需在where子句中将‘:$FLEX$.CUXINV_ORG’赋给需要屏蔽的条件
                例如:
                        在库存中物料的参数lov需要根据库存组织来屏蔽,只需在where子句中添加如下条件:‘o.ORGANIZATION_ID = :$FLEX$.CUXINV_ORG’
                说明:$FLEX$为固定符号,CUXINV_ORG为库存组织的值集名,FLEX一定要大写
                注意:只有库存组织已经选好以后才会出现相应的物料值列表
    7>.附加列:如果在想要在参数的lov中显示不止一列的值时,但不需要返回出来的,可以在附加列中添加相应要显示的列,要加上别名
    (标识中的列没有显示在lov中)
    8>.点击测试,没问题的保存

    2、固定的值

    特殊说明:如果定义成独立的验证类型时,进行数据库迁移的时候会产生错误,因此开发环境中不要选择独立的验证类型;有需要独立的验证类型也从表中验证;

    2.1 在值集界面将值的验证类型设置为”独立“
    2.2 定义值集对用的值:验证--值
    输入值集名点击查找输入相应的code和名称
    更多相关内容
  • Pytorch:如何定义自己创建的数据

    千次阅读 2020-05-15 21:29:00
    在Pytorch中定义数据主要涉及到两个主要的类: Datasets DataLoader 1 Datasets 1.1 什么是Datasets? Datasets是我们用的数据的库,pytorch自带多种数据,如Cifar10、MNIST等 1.2为什么要定义...

    本文为个人知识学习的记录,未来可以复习回顾。

    在Pytorch中定义数据集主要涉及到两个主要的类:

    • Datasets

    • DataLoader

    1 Datasets

    1.1 什么是Datasets?

    Datasets是我们用的数据集的库,pytorch自带多种数据集,如Cifar10、MNIST等

    1.2 为什么要定义Datasets?

    Pytorch中有工具函数torch.utils.Data.DataLoader,通过这个函数我们在准备加载数据集使用mini-batch的时候可以使用多线程并行处理,这样可以加快我们准备数据集的速度。Datasets就是构建这个工具函数的实例参数之一。

    1.3 如何定义Datasets?

    Dataset类是Pytorch中图像数据集中最为重要的一个类,也是Pytorch中所有数据集加载类中应该继承的父类。其中父类中的两个私有成员函数必须被重载,否则将会触发错误提示:

    def __getitem__(self,index):
    
    def __len__(self):
    • __len__:返回数据集的大小
    • __getitem__:编写支持数据集索引的函数

    注:

    重点是 getitem函数,getitem接收一个index,然后返回图片数据和标签,这个index通常指的是一个list的index,这个list的每个元素就包含了图片数据的路径和标签信息。

    如何制作list?

    通常的方法是将图片的路径和标签信息存储在一个txt中,然后从该txt中读取。

    1.3.1 读取数据的基本流程

    • 制作存储了图片的路径和标签信息的txt
    • 将这些信息转化为list,该list每一个元素对应一个样本
    • 通过getitem函数,读取数据和标签,并返回数据和标签

    1.3.2 Datasets的整体框架

    from torchvision.utils.data import Dataset
    
    class MyDataset(Dataset):#需要继承Dataset
        def __init__(self):
            # TODO
            # 1. 初始化文件路径或文件名列表。
            #也就是在这个模块里,我们所做的工作就是初始化该类的一些基本参数。
            pass
        def __getitem__(self, index):
            # TODO
    
            #1.从文件中读取一个数据(例如,使用numpy.fromfile,PIL.Image.open)。
            #2.预处理数据(例如torchvision.Transform)。
            #3.返回数据对(例如图像和标签)。
            #这里需要注意的是,第一步:read one data,是一个data
            pass
        def __len__(self):
            # 应该将0更改为数据集的总大小。
    

    1.4 栗子

    此栗子为图像分割实验中创建自己的数据集:

    import os
    import cv2
    import numpy as np
    from torch.utils.data import Dataset
    
    
    # 训练集
    class TrainDataset(Dataset):  # 继承Dataset
        def __init__(self, data_path, transform=None):  # 制作一个list,将图片路径以及标签信息存储在一个txt中
            # 读取数据
            self.images = os.listdir(data_path + '/images')
            self.labels = os.listdir(data_path + '/masks')
    
            # 查看图片与标签数量是否一致
            assert len(self.images) == len(self.labels), 'Number does not match'
    
            self.transform = transform  # 定义做何种变换
    
            # 下面这才是重点,将数据与标签连接在一起,为了之后可以索引
            # 构建list列表
            self.images_and_labels = []  # 创建一个空列表
            for i in range(len(self.images)):  # 往空列表里装东西,为了之后索引
                self.images_and_labels.append(
                    (data_path + '/images/' + self.images[i], data_path + '/masks/' + self.labels[i])
                )
    
        def __getitem__(self, index):  # 读取数据和标签,并返回数据和标签
            # 读取数据
            image_path, label_path = self.images_and_labels[index]
            # 图像处理
            image = cv2.imread(image_path)  # 读取图像,(H,W,C)
            image = cv2.resize(image, (224, 224))  # 将图像尺寸变为 224*224
    
            # 对标签进行处理,从而可以与结果对比,得到损失值
            label = cv2.imread(label_path, 0)  # 读取标签,且为灰度图
            label = cv2.resize(label, (224, 224))  # 将标签尺寸变为 224*224
            # 由于是二值分类,所以有以下操作.背景为0, 目标为1
            label = label / 255  # 调整数值范围为[0,1.0],, 因为神经网络中也做同样处理
            label = label.astype('uint8')  # 因为转换为了整型,只需要整数部分,所以数值不为1的,全置0。
    
            # one-hot编码
            label = np.eye(2)[label]  # 此处矩阵由二维变成了三维度
            label = np.array(list(map(lambda x: abs(x-1), label))).astype('float32')  # 0变为1,1变为0
            label = label.transpose(2, 0, 1)  # (H,W,C) => (C,H,W)
    
            if self.transform is not None:
                image = self.transform(image)
            return image, label  # 返回索引
    
        def __len__(self):  # 必须写,返回数据集的长度
            return len(self.images)
    
    
    # 测试集
    class TestDataset(Dataset):
        def __init__(self, data_path, transform=None):
            self.images = os.listdir(data_path + '/images')
            self.transform = transform
            self.imgs = []
            for i in range(len(self.images)):
                # self.imgs.append(data_path + '/images/' + self.images[i])
                self.imgs.append(os.path.join(data_path, 'images/', self.images[i]))
    
        def __getitem__(self, item):
            img_path = self.imgs[item]
            img = cv2.imread(img_path)
            img = cv2.resize(img, (224, 224))
    
            if self.transform is not None:
                img = self.transform(img)
            return img
    
        def __len__(self):
            return len(self.images)
    
    
    if __name__ == '__main__':
        img = cv2.imread('../data/train/masks/150.jpg', 0)
        img = cv2.resize(img, (16, 16))
        img2 = img / 255
        cv2.imshow('pic1', img2)
        cv2.waitKey()
        print(img2)
    
        img3 = img2.astype('uint8')
        cv2.imshow('pic2', img3)
        cv2.waitKey()
        print(img3)
    
        # 下面开始矩阵就变成了3维
        hot1 = np.eye(2)[img3]  # 对标签矩阵的每个元素都做了编码,(0,1)背景元素,(1,0)目标元素
        print(hot1)
        print(hot1.ndim)
        print(hot1.shape)  # (16,16,2) C=16,H=16,W=16
    
        hot2 = np.array(list(map(lambda x: abs(x - 1), hot1))) # 变换一下位置。(1,0)背景元素,(0,1)目标元素
        print(hot2)
        print(hot2.ndim)
        print(hot2.shape)  # (16,16,2) C=16,H=16,W=16
    
        hot3 = hot2.transpose(2, 0, 1)
        print(hot3)  # (C=2,H=16,W=16)
    

    2 DataLoader

    Dataset类是读入数据集数据并且对读入的数据进行了索引。但是光有这个功能是不够用的,在实际的加载数据集的过程中,我们的数据量往往都很大,对此我们还需要一下几个功能:

    • 可以分批次读取:batch-size
    • 可以对数据进行随机读取,可以对数据进行洗牌操作(shuffling),打乱数据集内数据分布的顺序
    • 可以并行加载数据(利用多核处理器加快载入数据的效率)

    此时就需要Dataloader类,常用操作有:batch_size(每个batch的大小), shuffle(是否进行shuffle操作),num_workers(加载数据的时候使用几个子进程)。Dataloader这个类并不需要我们自己设计代码,我们只需要利用DataLoader类读取我们设计好的Dataset子类即可:

    from torchvision.utils.data import DataLoader
    
    train_loader = DataLoader(dataset=train_data, batch_size=6, shuffle=True ,num_workers=4)
    test_loader = DataLoader(dataset=test_data, batch_size=6, shuffle=False,num_workers=4)
    

    参考:https://blog.csdn.net/sinat_42239797/article/details/90641659

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Pytorch学习(三)定义自己的数据及加载训练

    万次阅读 多人点赞 2019-06-06 14:58:14
    对于如何定义自己的Datasets我讲从以下几个方面进行解说 ...Pytorch中有工具函数torch.utils.Data.DataLoader,通过这个函数我们在准备加载数据使用mini-batch的时候可以使用多线程并行处理,这样可以加快我...

    对于如何定义自己的Datasets我讲从以下几个方面进行解说
    **

    1.什么是Datasets?
    2.为什么要定义Datasets?
    3.如何定义Datasets?

    定义Datasets分为以下几个板块:

    1)Datasets的源代码及解说

    2)Datasets的整体框架及解说

    3)自己的Datasets框架及解说

    4)DataLoader的使用

    5)如何生成txt文件

    什么是Datasets?

    Datasets是我们用的数据集的库,我们知道pytorch自带多种数据集列如Cifar10数据集就是在pytorch的Datasets的库中的。

    为什么要定义Datasets?

    Pytorch中有工具函数torch.utils.Data.DataLoader,通过这个函数我们在准备加载数据集使用mini-batch的时候可以使用多线程并行处理,这样可以加快我们准备数据集的速度。Datasets就是构建这个工具函数的实例参数之一。

    如何定义Datasets?

    Dataset类
    Dataset类是Pytorch中图像数据集中最为重要的一个类,也是Pytorch中所有数据集加载类中应该继承的父类。其中父类中的两个私有成员函数必须被重载,否则将会触发错误提示:

    def getitem(self, index):
    def len(self):
    

    其中__len__应该返回数据集的大小,而__getitem__应该编写支持数据集索引的函数
    这里重点看 getitem函数,getitem接收一个index,然后返回图片数据和标签,这个index通常指的是一个list的index,这个list的每个元素就包含了图片数据的路径和标签信息。

    然而,如何制作这个list呢,通常的方法是将图片的路径和标签信息存储在一个txt中,然后从该txt中读取。
    那么读取自己数据的基本流程就是:

    制作存储了图片的路径和标签信息的txt
    将这些信息转化为list,该list每一个元素对应一个样本
    通过getitem函数,读取数据和标签,并返回数据和标签

    定义自己的数据集类

    1)Datasets的源代码及解说

    All datasets are subclasses of torch.utils.data.Dataset i.e,
     they have __getitem__ and __len__ methods implemented. 
     Hence, they can all be passed to a torch.
     utils.data.DataLoader which can load multiple samples parallelly using torch.multiprocessing workers. 
    

    [源代码地址(https://pytorch.org/docs/stable/torchvision/datasets.html)
    从源代码我们可以看出继承Datasets必须继承__init_()和__getitim__()
    首先继承上面的dataset类。然后在__init__()方法中得到图像的路径,然后将图像路径组成一个数组,这样在__getitim__()中就可以直接读取.

    2)Datasets的整体框架及解说

    class FirstDataset(data.Dataset):#需要继承data.Dataset
        def __init__(self):
            # TODO
            # 1. 初始化文件路径或文件名列表。
            #也就是在这个模块里,我们所做的工作就是初始化该类的一些基本参数。
            pass
        def __getitem__(self, index):
            # TODO
    
            #1。从文件中读取一个数据(例如,使用numpy.fromfile,PIL.Image.open)。
             #2。预处理数据(例如torchvision.Transform)。
             #3。返回数据对(例如图像和标签)。
            #这里需要注意的是,第一步:read one data,是一个data
            pass
        def __len__(self):
            # 您应该将0更改为数据集的总大小。
    

    3)自己的Datasets框架及解说

      #***************************一些必要的包的调用********************************
        import torch.nn.functional as F
        import torch
        import torch 
        import torch.nn as nn
        from torch.autograd import Variable
        import torchvision.models as models
        from torchvision import transforms, utils
        from torch.utils.data import Dataset, DataLoader
        from PIL import Image
        import numpy as np
        import torch.optim as optim
        import os
        #***************************初始化一些函数********************************
        #torch.cuda.set_device(gpu_id)#使用GPU
        learning_rate = 0.0001#学习率的设置
        
        #*************************************数据集的设置****************************************************************************
        root =os.getcwd()+ '/data1/'#数据集的地址
         #定义读取文件的格式
        def default_loader(path):
            return Image.open(path).convert('RGB')
    
        class MyDataset(Dataset): 
                                     #创建自己的类: MyDataset,这个类是继承的torch.utils.data.Dataset
                #**********************************  #使用__init__()初始化一些需要传入的参数及数据集的调用**********************
    	 def __init__(self,txt, transform=None,target_transform=None, loader=default_loader):
    	                          
    		super(MyDataset,self).__init__()
    		                       #对继承自父类的属性进行初始化
    		fh = open(txt, 'r')
    		            #按照传入的路径和txt文本参数,以只读的方式打开这个文本
    		for line in fh: #迭代该列表#按行循环txt文本中的内
    			line = line.strip('\n')
    			line = line.rstrip('\n')
    			             # 删除 本行string 字符串末尾的指定字符,这个方法的详细介绍自己查询python
    			words = line.split()
    			           #用split将该行分割成列表  split的默认参数是空格,所以不传递任何参数时分割空格
    			imgs.append((words[0],int(words[1])))
    			         #把txt里的内容读入imgs列表保存,具体是words几要看txt内容而定 
                        # 很显然,根据我刚才截图所示txt的内容,words[0]是图片信息,words[1]是lable       
    		self.imgs = imgs
    		self.transform = transform
    		self.target_transform = target_transform
    		self.loader = loader        
                #*************************** #使用__getitem__()对数据进行预处理并返回想要的信息**********************
    	def __getitem__(self, index):#这个方法是必须要有的,用于按照索引读取每个元素的具体内容
    		fn, label = self.imgs[index]
    		                   #fn是图片path #fn和label分别获得imgs[index]也即是刚才每行中word[0]和word[1]的信息
    		img = self.loader(fn) 
    		                  # 按照路径读取图片
    		if self.transform is not None:
    			img = self.transform(img) 
    			                    #数据标签转换为Tensor
    		return img,label
    		                  #return回哪些内容,那么我们在训练时循环读取每个batch时,就能获得哪些内容
    		     #**********************************  #使用__len__()初始化一些需要传入的参数及数据集的调用**********************
    	def __len__(self):
    	        #这个函数也必须要写,它返回的是数据集的长度,也就是多少张图片,要和loader的长度作区分
    		return len(self.imgs)
    train_data=MyDataset(txt=root+'train.txt', transform=transforms.ToTensor())
    test_data = MyDataset(txt=root+'text.txt', transform=transforms.ToTensor())
    

    这里就不在详细描述,代码中注释的非常清楚,下面对一些小问题进行详细的说明:

    问题1.为什么返回的是RGB?

     def default_loader(path):
                return Image.open(path).convert('RGB')
    

    答:对于彩色图像,不管其图像格式是PNG,还是BMP,或者JPG,在PIL中,使用Image模块的open()函数打开后,返回的图像对象的模式都是“RGB”。
    而对于灰度图像,不管其图像格式是PNG,还是BMP,或者JPG,打开后,其模式为“L”。

    问题2:为什么word[0]是图片信息word[1]是标签信息

    		imgs.append((words[0],int(words[1])))
    		         #把txt里的内容读入imgs列表保存,具体是words几要看txt内容而定 
                    # 很显然,根据我刚才截图所示txt的内容,words[0]是图片信息,words[1]是lable 
    

    在生成txt文件的时候我默认设定的是第一部分是图片信息,第二部分是标签信息,当然如果你不喜欢这个顺序可以更改。
    在这里插入图片描述
    4)DataLoader的使用

    从上面Datasets源代码中可以知道定义Datasets还会遇到DataLoader类,它可以 调utils.data.DataLoader,可以使用torch.multiprocessing worker并行加载多个样本。
    DataLoader类
    之前所说的Dataset类是读入数据集数据并且对读入的数据进行了索引。但是光有这个功能是不够用的,在实际的加载数据集的过程中,我们的数据量往往都很大,对此我们还需要一下几个功能:
    batch_size:可以分批次读取

    shuffle=True可以对数据进行随机读取,可以对数据进行洗牌操作(shuffling),打乱数据集内数据分布的顺序

    num_workers=2可以并行加载数据(利用多核处理器加快载入数据的效率

    batch :可以分批次读取:batch-size

    这时候就需要Dataloader类了,Dataloader这个类并不需要我们自己设计代码,我们只需要利用DataLoader类读取我们设计好的ShipDataset即可:

    train_loader = DataLoader(dataset=train_data, batch_size=6, shuffle=True ,num_workers=4)
    test_loader = DataLoader(dataset=test_data, batch_size=6, shuffle=False,num_workers=4)
    

    简单的读取数据集的操作大体上就是这样的,当然实际应用中可能会与更加复杂的操作,这里就不进行复杂的描述了,具体的大家可以看一下官方网的源代码

    5)如何生成txt文件

    除了上面的读取数据集的代码,我们实际的图像数据应该怎么去放置呢?这就要用到txt文件了。
    一般来说,我们自己制作的数据集一般包含三个部分:训练集、验证集和测试集。
    因为数据集较大,所以一般我们将这三个模块分别放到三个文件夹下面,利用代码直接调用吗,简单又方便而且不容易出错。
    调用的时候,我们不仅要调用图片还有图片的路径和标签信息等,所以我们使用txt文件,在txt文件中加入两种信息,一种是图片的路径,我们可以通过图片的路径来找到图,从而读取图片;另一种是图片的标签,将每张图片的信息和标签一 一对应。
    下面是生成图片的txt文件的代码:

    import os
    a=0
    while(a<1024):#1024为我们的类别数
        dir = './data1/images/'#图片文件的地址
        label = a
    #os.listdir的结果就是一个list集,可以使用list的sort方法来排序。如果文件名中有数字,就用数字的排序
        files = os.listdir(dir)#列出dirname下的目录和文件
        files.sort()#排序
        train = open('./data1/train.txt','a')
       text = open('./data1/text.txt', 'a')
        i = 1
        for file in files:
            if i<200000:
                fileType = os.path.split(file)#os.path.split():按照路径将文件名和路径分割开
                if fileType[1] == '.txt':
                    continue
                name =  str(dir) +  file + ' ' + str(int(label)) +'\n'
                train.write(name)
                i = i+1
               
            else:
                fileType = os.path.split(file)
                if fileType[1] == '.txt':
                    continue
                name = str(dir) +file + ' ' + str(int(label)) +'\n'
                text.write(name)
                i = i+1
        text.close()
        train.close()
    

    生成txt文件这里引用了文章https://blog.csdn.net/Jack_and_monkey/article/details/86677253
    本文定义数据集的整个代码如下:

    import torch.nn.functional as F
    import torch
    import torch 
    import torch.nn as nn
    from torch.autograd import Variable
    import torchvision.models as models
    from torchvision import transforms, utils
    from torch.utils.data import Dataset, DataLoader
    from PIL import Image
    import numpy as np
    import torch.optim as optim
    import os
    
    #torch.cuda.set_device(gpu_id)#使用GPU
    learning_rate = 0.0001
    
    #数据集的设置*****************************************************************************************************************
    root =os.getcwd()+ '/data1/'#调用图像
    
    #定义读取文件的格式
    def default_loader(path):
        return Image.open(path).convert('RGB')
    
    #首先继承上面的dataset类。然后在__init__()方法中得到图像的路径,然后将图像路径组成一个数组,这样在__getitim__()中就可以直接读取:
    class MyDataset(Dataset): #创建自己的类:MyDataset,这个类是继承的torch.utils.data.Dataset
    	def __init__(self,txt, transform=None,target_transform=None, loader=default_loader): #初始化一些需要传入的参数
    		super(MyDataset,self).__init__()#对继承自父类的属性进行初始化
    		fh = open(txt, 'r')#按照传入的路径和txt文本参数,打开这个文本,并读取内容
    		imgs = []
    		for line in fh: #迭代该列表#按行循环txt文本中的内
    			line = line.strip('\n')
    			line = line.rstrip('\n')# 删除 本行string 字符串末尾的指定字符,这个方法的详细介绍自己查询python
    			words = line.split() #用split将该行分割成列表  split的默认参数是空格,所以不传递任何参数时分割空格
    			imgs.append((words[0],int(words[1]))) #把txt里的内容读入imgs列表保存,具体是words几要看txt内容而定 
                                                     # 很显然,根据我刚才截图所示txt的内容,words[0]是图片信息,words[1]是lable       
    		self.imgs = imgs
    		self.transform = transform
    		self.target_transform = target_transform
    		self.loader = loader        
            
    	def __getitem__(self, index):#这个方法是必须要有的,用于按照索引读取每个元素的具体内容
    		fn, label = self.imgs[index] #fn是图片path #fn和label分别获得imgs[index]也即是刚才每行中word[0]和word[1]的信息
    		img = self.loader(fn) # 按照路径读取图片
    		if self.transform is not None:
    			img = self.transform(img) #数据标签转换为Tensor
    		return img,label#return回哪些内容,那么我们在训练时循环读取每个batch时,就能获得哪些内容
    	def __len__(self): #这个函数也必须要写,它返回的是数据集的长度,也就是多少张图片,要和loader的长度作区分
    		return len(self.imgs)
     #根据自己定义的那个MyDataset来创建数据集!注意是数据集!而不是loader迭代器
    #*********************************************数据集读取完毕********************************************************************
    #图像的初始化操作
    train_transforms = transforms.Compose([
        transforms.RandomResizedCrop((227,227)),
        transforms.ToTensor(),
    ])
    text_transforms = transforms.Compose([
        transforms.RandomResizedCrop((227,227)),
        transforms.ToTensor(),
    ])
    
    #数据集加载方式设置
    train_data=MyDataset(txt=root+'train.txt', transform=transforms.ToTensor())
    test_data = MyDataset(txt=root+'text.txt', transform=transforms.ToTensor())
    #然后就是调用DataLoader和刚刚创建的数据集,来创建dataloader,这里提一句,loader的长度是有多少个batch,所以和batch_size有关
    train_loader = DataLoader(dataset=train_data, batch_size=6, shuffle=True,num_workers=4)
    test_loader = DataLoader(dataset=test_data, batch_size=6, shuffle=False,num_workers=4)
    print('num_of_trainData:', len(train_data))
    print('num_of_testData:', len(test_data))
    

    这里图片的初始化操作未做详细的描述,具体的大家可以看我的另一篇文章
    (https://blog.csdn.net/sinat_42239797/article/details/90373471)

    展开全文
  • 找到的名为“Infragistics.WebUI.UltraWebGrid.ExcelExport.v3.1”的程序清单定义与程序引用不匹配。  其中Infragistics.WebUI.UltraWebGrid.ExcelExport.v3.1是我们程序中用到的第三方控件。我自己也是第一...
     上午在打开一个Asp.net网页时出现了这样的错误信息:
    找到的名为“Infragistics.WebUI.UltraWebGrid.ExcelExport.v3.1”的程序集清单定义与程序集引用不匹配
      其中Infragistics.WebUI.UltraWebGrid.ExcelExport.v3.1是我们程序中用到的第三方控件。我自己也是第一次遇到这样的问题,咋一看估计是版本问题。但也不知道真正原因是什么以及该如何解决。上午查找了相应的资料将该“报错”成功解决。
     
      既然是“程序集清单”和“程序集引用”不匹配。那让我们先来看看什么是“程序集清单”。
     
      什么是程序集清单(Assembly Manifest)?
      我们知道,在.net中。程序是以程序集为单位进行打包的,通常一个.exe文件或一个.dll文件就是一个程序集。程序集一般包含了以下几个部分:
    1, 程序集清单(或者叫程序集元数据);
    2,类型元数据;
    3,MSIL代码;
    4,资源(可选项).
    如此说来,一般情况下一个.exe或.dll都会包含这此内容。
      在程序集中, 程序集 清单(manifest)是比较重要的,简单地讲它包含了一个程序集需要引用的外部分文件及程序集所包含的内容。其实也就是微软说的“自我说明”。我们可以通过Visual Studio2003自带的ILDASM工具查看该清单:
      1,打开ILDASM,一般位于:VS2003安装目录\SDK\v1.1\Bin\目录下。
      2,打开ILDASM,后选择 文件->打开,将想要查看的程序集加进来。
      3,双击“MANIFEST”;
    打开后会看到如下内容:
    上图的MANIFEST就是程序清单,像红线部分标出的是该程序集需要引用到外部文件 Infragistics.WebUI.UltraWebGrid.ExcelExport.v3.1,同时也标识了版本号和密钥。
      至此,我们知道是什么是程序集清单以及怎么样查看一个程序集清单了。下面我们再看看什么是程序集引用。
     
      什么是程序集的引用?
      在VS2003下编程的朋友们都知道,当我们用第三方控件,或是别人写的DLL时,我所要做的就是将其引用进来。引用一个程序集的动作分为两步:
    首先,在项目中将需要的引用的程序集“添加至”引用中。
    其次,在源文件件引入(using namespace)别人的命名空间; 
    如下:
     
       如此将其引用进来以后,我们就可以使用该第三方控件提供的类、方法、资源等功能了。比如我们将“System.Data.SqlClient”引入以后,我们就可以通过其提供的类进行数据库的连接及操作了。
     
       现在知道什么是“程序集清单”了,知道什么是“程序集引用”。问题也相对明了了。程序引用中的第三方控件的版本号(我这边是路径导致的)和最终生成的程序集清单所需的版本号并不相符。
       .net的CLR在执行一个程序时(如.exe)时或使用一个.dll时,他会首先查看其程序集(.exe或.dll)的程序集清单,找到运行该程序所引用的程序集并加载。.net会按一定的路径搜索,加载.若加载的版本和程序清单中的不一致时就会出现类似"程序集清单定义与程序集引用不匹配"报错。
     
    展开全文
  • 机器学习(概述一)——定义

    万次阅读 2019-05-28 16:18:17
    在监督学习的过程中,我们只需要给定输入样本,机器就可以从中推演出指定目标变量的可能结果。监督学习相对比较简单,机器只需从输入数据中预测合适的模型,并从中计算出目标变量的结果。 监督学习一般使用两种...
  • 找到的程序清单定义与程序引用不匹配。 (异常来自 HRESULT:0x80131040) 类似问题: 未能加载文件或程序xxxxx或它的某一个依赖项。找到的程序清单定义与程序引用不匹配。 (异常来自 HRESULT:0x80131040...
  •  DBLP(如果你要做异构信息网络这个方向,你会经常和这个数据打交道) 3.定义三,网络模式?( Network schema )   异构信息网络( G  = ( V, E )with  ϕ ( v )  ∈ A 并且  ψ ( e )  ...
  • 在java中怎么定义一个全局变量

    千次阅读 2021-02-12 09:55:44
    展开全部在一个全局类里面e68a84e8a2ad62616964757a686964616f31333361313837定义公共静态变量publicclassGlobal{publicstaticintabc=0;publicstaticintdef=0;}------解决方案--------------------/***Title:Global*...
  • 1.错误信息: 错误 CS0012 类型“Enum”在未引用的程序集中定义。必须添加对程序“mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089”的引用。 A3200 (netstandard1.4) 2.尝试...
  • 多模态定义

    千次阅读 2021-08-15 22:22:35
    同时,模态也可以有非常广泛的定义,比如我们可以把两种不同的语言当做是两种模态,甚至在两种不同情况下采集到的数据,亦可认为是两种模态。 因此,多模态机器学习,英文全称 MultiModal Machine Learning (MMML)...
  • IFC属性及属性

    千次阅读 热门讨论 2018-08-02 15:50:37
     静态属性以 IFC 实体的方式定义,其属性以IFC schema 的方式静态的定义在属 性 中 , 如 IfcDoorLiningProperties 、 IfcDoorPanelProperties 、IfcSoundProperties。  动态属性以 ...
  • 模糊通常先要划分论域U,再定义一个隶属度函数(membership function)来表示元素对U在[0, 1]上的映射。常用的隶属度函数有高斯隶属度函数,区间隶属度函数,三角隶属度函数,梯形隶属度函数。 二型模糊 一型模糊...
  • 16个车辆信息检测数据收集汇总(简介及链接)

    万次阅读 多人点赞 2020-10-15 14:46:34
    车辆信息检测数据收集汇总 1.UA-DETRAC http://detrac-db.rit.albany.edu/ UA-DETRAC是一个具有挑战性的真实世界多目标检测和多目标跟踪基准。该数据包括在中国北京和天津的24个不同地点使用Cannon EOS ...
  • 必须添加对程序“System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a”的引用 查找网上一些解决方案,在微软官网找到同样问题 最后解决方案: 在web.config文件...
  • SSAS 定义和部署多维数据

    千次阅读 2016-10-07 21:27:38
    摘要:数据源试图创建之后,就可以定义多维数据。可以使用多维数据向导,通过单个步骤定义一个多维数据及其维度。也可以先定义一个或多个维度,然后使用多维数据向导定义一个使用这些维度的多维数据。如果...
  • 信息论:熵与互信息

    万次阅读 多人点赞 2016-11-25 21:18:43
    这篇文章主要讲:熵, 联合熵(joint entropy),条件熵(conditional entropy),相对熵(relative entropy,KL 距离),互信息(mutual information),交叉熵(cross entropy),困惑度(perplexity)。 ...
  • string数组string数组的定义有三种:String arr[] = new String[10]; //创建一个长度为10的String 类型数组。String arr[] = {"张三","李四"};String[] arr = new String[10];相关阅读分析:如果直接输出未初始化的...
  • 在未引用的程序集中定义 必须添加对程序"System.data......"的引用 【解决方法 1 】网上寻找的结果大概为 [此处的解决方法参考的是 csdn: jiande870929]pda与pc端的dll文件的大小是不同的 但是如果...
  • 大数据的定义

    万次阅读 2018-09-27 09:21:52
    “大数据”是需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力来适应海量、高增长率和多样化的信息资产。 [1] 麦肯锡全球研究所给出的定义是:一种规模大到在获取、存储、管理、分析方面大大超出了...
  • 计算机网络的定义以及分类

    千次阅读 2021-02-16 07:40:24
    所有的网络信息都是通过中央线器(节点)进行通信的,周围的节点将信息传输给中央线器,中央节点将所接收的信息进行处理加工从而传输给其他的节点。星型网络拓扑结构的主要特点在于建网简单、结构易构、便于管理...
  • 【Linux】Linux的信号量

    万次阅读 2018-08-18 22:33:08
    所谓信号量,就是由多个信号量组成的一个数组。作为一个整体,信号量集中的所有信号量使用同一个等待队列。Linux的信号量为进程请求多个资源创造了条件。Linux规定,当进程的一个操作需要多个共享资源时,如果只...
  • 1.信息熵的理论背景 在机器学习的过程中,我们经常会进行数据的准备工作。那么怎么来评测我们划分的数据,来证明我们的划分就是最好最合理的呢?这里我们就需要用到信息熵了。熵越大,随机变量的不确定性就越大...
  • 粗糙理论

    万次阅读 多人点赞 2019-08-24 20:42:05
    概念、可定义集2.1 信息表2.2 决策逻辑语言 $\mathbb{L}$2.3 可定义集 的 形式化定义定义一(子集可定义):2.4 等价关系E(A)| 不可分辨关系3 . 近似空间、上下近似3.1 近似空间3.2 上下近似定义二(近似算子):决策...
  • 用AdoQuery从脚本文件读入内容,执行时提示“不正常地定义参数对象”,“提供了不一致或不完整的信息”之类的错误,本以为是SQL语句有问题,用查询分析器执行时没有发现错误,一切OK。但一到Delphi中执行就提示“不...
  • DICOM标准之三_信息对象定义1

    千次阅读 2012-07-17 14:52:38
    第3部分 信息对象定义(1) 1.应用范围和层次 Dicom标准的本部分明确了一套信息对象定义(IOD),提供了可应用于数字医疗信息的真实世界对象的抽象定义。 对于每个IOD,本部分明确了: 1)IOD语义描述的任何所需信息; 2...
  • openPCdet 实现自定义点云数据训练

    千次阅读 热门讨论 2022-03-14 15:01:46
    激光雷达三位感知 openPCdet 数据训练
  • 频繁项&频繁闭项&最大频繁

    万次阅读 多人点赞 2016-06-24 23:37:36
    频繁项&频繁闭项&最大频繁

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 754,954
精华内容 301,981
关键字:

信息集的定义