pytorch 가 자체 데이터 세트 를 읽 는 데 발생 한 문 제 를 해결 합 니 다.

11880 단어 pytorch읽 기데이터 세트
질문
질문 설명:
TypeError: default_collate: batch must contain tensors, numpy arrays, numbers, dicts or lists; found
해결 방법
데이터 형식 이 틀 렸 습 니 다.image 를 tensor 로 바 꾸 고 인자 transform 을 다음 과 같이 설정 하면 됩 니 다.transform=transform.Totensor().transform 검사 에 주의 하 세 요.
문제
질문 설명:
TypeError: append() takes exactly one argument (2 given)
문제점

imgs.append(words[0], int(words[1]))
해결 방법
괄호 를 달다

imgs.append((words[0], int(words[1])))
질문
문제 설명
RuntimeError: Input type (torch.cuda.FloatTensor) and weight type (torch.FloatTensor) should be the same
해결 방법
데이터 와 모델 은 같은 장치 에 있 지 않 습 니 다.모두 GPU 에서 실행 되 거나 CPU 에 있 을 것 입 니 다.
문제
문제 설명
RuntimeError: Given groups=1, weight of size [64, 1, 3, 3], expected input[1, 3, 512, 512] to have 1 channels, but got 3 channels instead
해결 방법
그림 이 RGB 라 니............................................................................
보충:신경 망 pytorch 데이터 세트 읽 기(데이터 세트 자동 읽 기,수 동 으로 자신의 데 이 터 를 읽 기)
pytorch 에 대해 저 희 는 이미 포 장 된 데이터 세트 를 사용 할 수 있 고 자신의 데이터 세트 를 만 들 수 있 습 니 다.대체적으로 세 가지 방법 이 있 습 니 다.그 중에서 사용 하 는 두 개의 가방 은 datasets 와 DataLoader 입 니 다.
datasets:데이터 와 라벨 을 데이터 세트 로 포장 하 는 데 사용 합 니 다.
DataLoader:데이터 세트 를 고급 처리 하 는 데 사 용 됩 니 다.예 를 들 어 그룹,흐 트 러 짐,처리 등 은 훈련 과 테스트 에서 DataLoader 를 직접 사용 하여 처리 할 수 있 습 니 다.
첫 번 째 이미 만들어 진 포장 데이터 세트
이런 비교적 간단 한 대답 은 기 존의 몇 줄 코드 와 하나의 경로 만 있 으 면 완성 할 수 있 지만 보통 cifar-10 과 같은 자주 사용 된다.

상용 데이터 세트 에 대해 서 는 torchvision.datasets 를 사용 하여 직접 읽 을 수 있 습 니 다.이것 은 자주 사용 하 는 처리 입 니 다.이 클래스 도 torch.utils.data.dataset 에 계승 되 었 습 니 다.

#                       root         
#         
 
#          CIFAR10          
#   
transform = transform.Compose([transform.ToTensor(), transform.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
#     
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform)
#   DataLoader
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=1)
 
#  
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform)
testloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=False, num_workers=1)
classes = (1,2,3,4,5,6,7,8,9,10)  #    
 
#  
 for epoch in range(3):
        running_loss = 0.0 #  loss
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data #trainloader  ：id,image,labels
 
            #  inputs labels  Variable 
            inputs, labels = Variable(inputs), Variable(labels)
            
            #  print    
            print("epoch：", epoch, "  ", i, " inputs", inputs.data.size(), "labels", labels.data.size())

두 번 째 자신의 이미지 분류
이것 도 편리 한 방법 입 니 다.pytorch 에서 torchvision.datasets.ImageFolder 를 제공 하여 자신의 이미 지 를 훈련 시 킵 니 다.
요구:train 과 test 폴 더 를 만 들 고 폴 더 마다 분류 이름 에 따라 그림 을 저장 하면 dataloader 를 실현 할 수 있 습 니 다.
여기 서 는 그래도 예 를 들 어 보 자.사실은 우리 의 데이터 세트 일 수도 있다.

각 아래 의 배 치 는 이렇다.

#    
transform = transform.Compose([transform.ToTensor(), transform.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
 
#  torchvision.datasets.ImageFolder        train   test   
img_data = torchvision.datasets.ImageFolder('data/cifar-10/train/', transform=transform)
data_loader = torch.utils.data.DataLoader(img_data, batch_size=4, shuffle=True, num_workers=1)
 
testset = torchvision.datasets.ImageFolder('data/cifar-10/test/', transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=True, num_workers=1)
 
 for epoch in range(3):
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data #trainloader  ：id,image,labels
            #  inputs labels  Variable 
            inputs, labels = Variable(inputs), Variable(labels)
 
            #  print    
            print("epoch：", epoch, "  ", i, " inputs", inputs.data.size(), "labels", labels.data.size())
세 번 째 1 차원 벡터 데이터 세트
이것 은 비교적 난감 한 것 이다.우선 우리 는
txt 등 파일 에 수 를 저장 하고 그 를 먼저 읽 으 면 읽 은 부분 은 자세히 말 하지 않 고 목록 에 읽 으 면 됩 니 다.
목록

trainlist = []  #        
 
targetpath = 'a/b/b'
filelist = os.listdir(targetpath) #              
filecount = len(filelist)
#                           list
for i in range(filecount):
     filepath = os.path.join(targetpath, filelist[j])
     with open(filepath, 'r') as f:
         line = f.readline()
         #         1,2,3,4,5,6          
         templist = list(map(int, line.split(',')))
         trainlist.append(templist)
 
#              filecount               
#       Tensor
 
#              list0   list1 
split = len(list0) #          
 
#  numpy.array   torch.from_numpy        tensor    torch.cat  
train0_numpy = numpy.array(list0)
train1_numpy = numpy.array(list1)
train_tensor = torch.cat([torch.from_numpy(train0_numpy), torch.from_numpytrain1_numpy)], 0)
#      【   ，  】                   【   ，  ，  】
#                            RGB       【3， ， 】           
#                    
#             
shaper = train_tensor.shape  #     【   ，  】
aa = torch.ones((shaper[0], 1, shaper[1])) #       
for i in range(shaper[0]):  #            
・    aa[i][0][:] = train_tensor[i][:]
train_tensor = aa  #           【   ，  ，  】
 
#                        【   ，  ，size_w,size_h】
#                                      
  
#                     split         
#      
total = len(list0) + len(list1)
train_label = numpy.zeros(total)
train_label[split+1:total] = 1
train_label_tensor = torch.from_numpy(train_label).int()
# print(train_tensor.size(),train_label_tensor.size())
 
#   dataloader  
train_dataset = TensorDataset(train_tensor, train_label_tensor)
train_loader = DataLoader(dataset=train_dataset, batch_size=4, shuffle=True)
 
for epoch in range(3):
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data #trainloader  ：id,image,labels
        #  inputs labels  Variable 
        inputs, labels = Variable(inputs), Variable(labels)
 
        #  print    
        print("epoch：", epoch, "  ", i, " inputs", inputs.data.size(), "labels", labels.data.size())
네 번 째 경로 와 탭 을 저장 하 는 방식 으로 데이터 세트 를 만 듭 니 다.
이 방법 은 약간의 번 거 로 움 이 필요 합 니 다.우선 txt 가 있 습 니 다.파일 이름과 대응 하 는 탭 을 저장 하 였 습 니 다.아마도 이 뜻 일 것 입 니 다.

그리고 프로그램 에서 주어진 루트 디 렉 터 리 에 따라 파일 을 찾 고 탭 을 저장 합 니 다.

class Dataset(object):
"""An abstract class representing a Dataset.
All other datasets should subclass it. All subclasses should override
``__len__``, that provides the size of the dataset, and ``__getitem__``,
supporting integer indexing in range from 0 to len(self) exclusive.
"""
def __getitem__(self, index):
	raise NotImplementedError
def __len__(self):
	raise NotImplementedError
def __add__(self, other):
	return ConcatDataset([self, other])
이것 은 dataset 의 원래 내용 입 니 다.getitem 은 요 소 를 가 져 오 는 부분 으로 index 에 대응 하 는 데이터 와 탭 을 되 돌려 줍 니 다.그러면 대개 해 야 할 일 은 txt 의 내용 을 읽 고 프로그램 으로 태그 와 데 이 터 를 처리 하 는 것 입 니 다.

# coding: utf-8
from PIL import Image
from torch.utils.data import Dataset
class MyDataset(Dataset):
#      txt       
def __init__(self, txt_path, transform = None, target_transform = None):
	fh = open(txt_path, 'r')
	imgs = []
	for line in fh:
		line = line.rstrip()
		words = line.split()
         #                  
		imgs.append((words[0], int(words[1])))
		self.imgs = imgs 
		self.transform = transform
		self.target_transform = target_transform
def __getitem__(self, index):
	fn, label = self.imgs[index]
	img = Image.open(fn).convert('RGB') 
	if self.transform is not None:
		img = self.transform(img) 
    #        
    
	return img, label
def __len__(self):
	return len(self.imgs)
 
#        myImageFloder  txt        
import os
import torch
import torch.utils.data as data
from PIL import Image 
def default_loader(path):
    return Image.open(path).convert('RGB')
 
class myImageFloder(data.Dataset):
    def __init__(self, root, label, transform = None, target_transform=None, loader=default_loader):
        fh = open(label) #  label  
        c=0
        imgs=[]  #        
        class_names=[]
        for line in  fh.readlines(): #       
            if c==0:
                class_names=[n.strip() for n in line.rstrip().split('	')] 
            else:
                cls = line.split() #     
                fn = cls.pop(0)  #       
                if os.path.isfile(os.path.join(root, fn)):  #           
                    imgs.append((fn, tuple([float(v) for v in cls])))  #     
            c=c+1
 
        #     
        self.root = root
        self.imgs = imgs
        self.classes = class_names
        self.transform = transform
        self.target_transform = target_transform
        self.loader = loader
 
    def __getitem__(self, index):  #          
        fn, label = self.imgs[index]  #           label
        img = self.loader(os.path.join(self.root, fn))
        if self.transform is not None:  #     
            img = self.transform(img)
        return img, torch.Tensor(label) #      label
 
    def __len__(self):
        return len(self.imgs)
    
    def getName(self):
        return self.classes
# 

#                
trainset = MyDataset(txt_path=pathFile,transform = None, target_transform = None)
# trainset = torch.utils.data.DataLoader(myFloder.myImageFloder(root = "../data/testImages/images", label = "../data/testImages/test_images.txt", transform = mytransform ), batch_size= 2, shuffle= False, num_workers= 2)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True, num_workers=8)
데이터 세트 를 계승 하여 초기 화 에서 txt 텍스트 데 이 터 를 처리 하고 해당 하 는 데 이 터 를 저장 하 며 해당 하 는 기능 을 실현 하 는 것 이 요점 입 니 다.
그 중의 원 리 는 바로 이와 같 지만 약간 부적 절 한 부분 이 있 을 수 있 으 므 로 그때 현장 테스트 가 필요 할 것 이다.
이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.
pytorch 는 어떻게 이미지 데이터 세트 를 train,test,val 로 나 눕 니까?
Python 취미 도전 용 pygame 간단 한 금화 회전 효과 구현

좋은 웹페이지 즐겨찾기

개발자 우수 사이트 수집

개발자가 알아야 할 필수 사이트 100선 추천 우리는 당신을 위해 100개의 자주 사용하는 개발자 학습 사이트를 정리했습니다
best100-homepage