Es gibt Leute, die Pytorch im Labor benutzen, also zur Erklärung für diese Person
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() #Iris-Datensatz wird geladen
self.data = self.iris['data']
self.label = self.iris['target']
self.datanum = len(self.label) #Gesamtzahl der Daten
self.transform = transform #Spezielle Datenverarbeitung
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("Anzahl der Daten: " + str(len(data[0])))
print("data: {}".format(data[0]))
print("Anzahl der Etiketten: " + str(len(data[1])))
print("label: {}".format(data[1]) + "\n")
Das ist der ganze Code. Ich habe es aus Gründen der Klarheit auf ein Minimum beschränkt.
init ist der Prozess, bei dem die Klasse definiert wird. Diesmal sind es sehr kleine Daten, also habe ich alles in init definiert, Wenn Sie sehr große Daten aus dem Speicher iterieren möchten, geben Sie hier den Pfad usw. an und iterieren Sie mit getitem in der angegebenen Reihenfolge.
len gibt die Gesamtzahl der Daten zurück.
getitem gibt die durch den Index angegebenen Daten zurück. Geben Sie beim Iterieren mit Dataloader die Daten für die später beschriebene Stapelgröße an und geben Sie sie zurück.
Übergeben Sie das Dataset, das eine Instanz der Dataset-Klasse ist, als erstes Argument. Für das zweite und dritte Argument entweder Stapelgröße oder Shuffle oder Pass __ (True / False) __. Setzen Sie shuffle auf True, es sei denn, Sie haben einen bestimmten Grund dafür.
Neben für gibt es noch andere Möglichkeiten, den Dataloader zu iterieren, aber hier verwenden wir für. Das obige Programm wird unten ausgeführt.
Anzahl der Daten: 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)
Anzahl der Etiketten: 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)
～～～～～ Unterwegs weggelassen ～～～～～～
Anzahl der Daten: 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)
Anzahl der Etiketten: 10
label: tensor([0, 1, 0, 2, 1, 2, 2, 0, 0, 1], dtype=torch.int32)
Sowohl die Daten als auch das Etikett werden korrekt ausgegeben, wobei jeweils 20 als Chargengröße definiert sind. 150/20 ist nicht so viel, aber Dataloader gibt 10 ohne Fehler aus. Es ist auch praktisch, dass es auf diese Weise ohne spezielle Verarbeitung eingestellt werden kann.
Dies ist ein einfaches Beispiel. Bitte kommentieren Sie, wenn Sie weitere Fragen haben. Wenn Sie einen Fehler machen, tun Sie dies bitte.
Recommended Posts