Il y a des gens qui utilisent Pytorch dans le laboratoire, donc pour une explication pour cette personne
dataset.py
import torch
from sklearn.datasets import load_iris
class Dataset(torch.utils.data.Dataset):
def __init__(self, transform=None):
self.iris = load_iris() #Chargement du jeu de données iris
self.data = self.iris['data']
self.label = self.iris['target']
self.datanum = len(self.label) #Nombre total de données
self.transform = transform #Traitement spécial des données
def __len__(self):
return self.datanum
def __getitem__(self, index):
data = self.data[index]
label = self.label[index]
if self.transform:
data = self.transform(data)
return data, label
if __name__ == "__main__":
batch_size = 20
dataset = Dataset()
dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)
for data in dataloader:
print("Nombre de données: " + str(len(data[0])))
print("data: {}".format(data[0]))
print("Nombre d'étiquettes: " + str(len(data[1])))
print("label: {}".format(data[1]) + "\n")
C'est tout le code. Je l'ai vraiment gardé au minimum pour plus de clarté.
init est le processus lorsque la classe est définie. Cette fois, ce sont de très petites données, donc j'ai tout défini dans init, Si vous voulez itérer des données très volumineuses à partir du stockage, spécifiez le chemin, etc. ici et c'est une bonne sensation d'itérer dans l'ordre avec getitem.
len renvoie le nombre total de données.
getitem renvoie les données spécifiées par index. Lors de l'itération avec Dataloader, spécifiez et renvoyez les données pour la taille de lot décrite plus loin.
Passez l'ensemble de données, qui est une instance de la classe Dataset, comme premier argument. Pour les deuxième et troisième arguments, sélectionnez la taille du lot ou la lecture aléatoire ou passez __ (Vrai / Faux) __. Définissez shuffle sur True, sauf si vous avez une raison spécifique de le faire.
Il existe d'autres façons d'itérer le Dataloader en plus de pour, mais ici nous utilisons pour. Le programme ci-dessus est exécuté ci-dessous.
Nombre de données: 20
data: tensor([[6.8000, 3.0000, 5.5000, 2.1000],
[6.7000, 3.1000, 5.6000, 2.4000],
[5.4000, 3.9000, 1.3000, 0.4000],
[5.5000, 2.4000, 3.7000, 1.0000],
[5.1000, 3.7000, 1.5000, 0.4000],
[4.5000, 2.3000, 1.3000, 0.3000],
[6.6000, 2.9000, 4.6000, 1.3000],
[6.5000, 3.0000, 5.8000, 2.2000],
[7.0000, 3.2000, 4.7000, 1.4000],
[4.4000, 3.2000, 1.3000, 0.2000],
[5.0000, 3.4000, 1.5000, 0.2000],
[5.4000, 3.4000, 1.5000, 0.4000],
[4.9000, 2.4000, 3.3000, 1.0000],
[6.3000, 3.4000, 5.6000, 2.4000],
[7.7000, 2.6000, 6.9000, 2.3000],
[6.2000, 2.8000, 4.8000, 1.8000],
[6.2000, 3.4000, 5.4000, 2.3000],
[5.6000, 2.7000, 4.2000, 1.3000],
[6.1000, 3.0000, 4.9000, 1.8000],
[6.7000, 3.0000, 5.0000, 1.7000]], dtype=torch.float64)
Nombre d'étiquettes: 20
label: tensor([2, 2, 0, 1, 0, 0, 1, 2, 1, 0, 0, 0, 1, 2, 2, 2, 2, 1, 2, 1],
dtype=torch.int32)
～～～～～ Omis en chemin ～～～～～～
Nombre de données: 10
data: tensor([[4.8000, 3.4000, 1.6000, 0.2000],
[6.1000, 2.8000, 4.7000, 1.2000],
[5.1000, 3.8000, 1.9000, 0.4000],
[6.7000, 3.3000, 5.7000, 2.1000],
[6.4000, 2.9000, 4.3000, 1.3000],
[7.4000, 2.8000, 6.1000, 1.9000],
[6.4000, 3.2000, 5.3000, 2.3000],
[5.0000, 3.3000, 1.4000, 0.2000],
[5.0000, 3.2000, 1.2000, 0.2000],
[5.8000, 2.7000, 4.1000, 1.0000]], dtype=torch.float64)
Nombre d'étiquettes: 10
label: tensor([0, 1, 0, 2, 1, 2, 2, 0, 0, 1], dtype=torch.int32)
Les données et l'étiquette sont sorties correctement avec 20 chacune définie comme taille de lot. 150/20 n'est pas tellement, mais Dataloader en sort 10 sans aucune erreur. Il est également pratique qu'il puisse être ajusté de cette manière sans aucun traitement spécial.
Ceci est un exemple simple, veuillez donc commenter si vous avez d'autres questions. Si vous faites une erreur, veuillez le faire.
Recommended Posts