PyTorch-Datenverarbeitung und Datenladen
In PyTorch ist die Verarbeitung und das Laden von Daten ein entscheidender Schritt im Deep-Learning-Trainingsprozess.
Um Daten effizient zu verarbeiten, bietet PyTorch leistungsstarke Werkzeuge, daruntertorch.utils.data.Datasetundtorch.utils.data.DataLoader, die uns helfen, Aufgaben wie Datensätze, Batch-Laden und Datenaugmentierung zu bewältigen.
Einführung in die Datenverarbeitung und das Laden von Daten mit PyTorch:
- Benutzerdefinierter Datensatz: Durch Vererbung
torch.utils.data.Datasetum Ihren eigenen Datensatz zu laden. - DataLoader:
DataLoaderDaten in Batches laden, mehrthreadiges Laden und Daten-Shuffling unterstützen. - Datenvorverarbeitung und Datenaugmentierung: Verwenden Sie
torchvision.transformsum gängige Bildvorverarbeitungs- und Augmentierungsoperationen durchzuführen und die Generalisierungsfähigkeit des Modells zu verbessern. - Laden von Standarddatensätzen:
torchvision.datasetsbietet viele gängige Datensätze und vereinfacht den Datenladeprozess. - Mehrere Datenquellen: Durch Kombinieren mehrerer
DatasetInstanzen, um Daten aus verschiedenen Quellen zu verarbeiten.
Benutzerdefinierter Datensatz
torch.utils.data.Datasetist eine abstrakte Klasse, mit der Sie Datensätze aus Ihren eigenen Datenquellen erstellen können.
Wir müssen diese Klasse erben und die folgenden zwei Methoden implementieren:
__len__(self): Gibt die Anzahl der Samples im Datensatz zurück.__getitem__(self, idx): Gibt ein Sample anhand des Index zurück.
Angenommen, wir haben eine einfache CSV-Datei oder einige Listendaten; wir können unseren eigenen Datensatz erstellen, indem wir von der Klasse Dataset erben.
Beispiel
from torch.utils.data import Dataset
# Benutzerdefinierte Dataset-Klasse
class MyDataset(Dataset):
def __init__(self, X_data, Y_data):
"""
Initialisiert den Datensatz; X_data und Y_data sind zwei Listen oder Arrays
X_data: Eingabemerkmale
Y_data: Ziel-Labels
"""
self.X_data = X_data
self.Y_data = Y_data
def __len__(self):
"""Gibt die Größe des Datensatzes zurück"""
return len(self.X_data)
def __getitem__(self, idx):
"""Gibt die Daten am angegebenen Index zurück"""
x = torch.tensor(self.X_data[idx], dtype=torch.float32) # In Tensor umwandeln
y = torch.tensor(self.Y_data[idx], dtype=torch.float32)
return x, y
# Beispieldaten
X_data = [[1, 2], [3, 4], [5, 6], [7, 8]] # Eingabemerkmale
Y_data = [1, 0, 1, 0] # Ziel-Labels
# Eine Datensatz-Instanz erstellen
dataset = MyDataset(X_data, Y_data)
Daten mit DataLoader laden
DataLoader ist ein wichtiges, von PyTorch bereitgestelltes Werkzeug, das verwendet wird, um Daten aus einem Dataset in Batches zu laden.
DataLoader ermöglicht es uns, Daten in Batches zu lesen und das Laden mit mehreren Threads durchzuführen, wodurch die Trainingseffizienz verbessert wird.
Beispiel
# Erstelle eine DataLoader-Instanz; batch_size legt die Anzahl der jeweils geladenen Samples fest
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)
# Gib die geladenen Daten aus
for epoch in range(1):
for batch_idx, (inputs, labels) in enumerate(dataloader):
print(f'Batch {batch_idx + 1}:')
print(f'Eingaben: {inputs}')
print(f'Labels: {labels}')
batch_size: Die Anzahl der jeweils geladenen Samples.shuffle: Ob die Daten gemischt werden sollen; normalerweise müssen die Daten während des Trainings gemischt werden.drop_last: Wenn die Anzahl der Samples im Dataset nicht ohne Rest durchbatch_size, wenn gesetzt aufTrue, den letzten unvollständigen Batch verwerfen.
Ausgabe:
Batch 1: Inputs: tensor([[3., 4.], [1., 2.]]) Labels: tensor([0., 1.]) Batch 2: Inputs: tensor([[7., 8.], [5., 6.]]) Labels: tensor([0., 1.])
In jeder Schleife gibt der DataLoader einen Batch von Daten zurück, der Eingabemerkmale (inputs) und Ziel-Labels (labels) enthält.
Vorverarbeitung und Datenaugmentation
Datenvorverarbeitung und Datenaugmentation sind entscheidend, um die Modellleistung zu verbessern.
PyTorch stellt das Modul torchvision.transforms bereit, um gängige Bildvorverarbeitungs- und Augmentierungsoperationen wie Rotation, Zuschneiden, Normalisierung usw. durchzuführen.
Gängige Operationen zur Bildvorverarbeitung:
Beispiel
from PIL import Image
# Datenvorverarbeitungspipeline definieren
transform = transforms.Compose([
transforms.Resize((128, 128)), # Bild auf 128x128 skalieren
transforms.ToTensor(), # Bild in einen Tensor umwandeln
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # Normalisieren
])
# Lade das Bild
image = Image.open('image.jpg')
# Vorverarbeitung anwenden
image_tensor = transform(image)
print(image_tensor.shape) # Gibt die Form des Tensors aus
transforms.Compose(): Kombiniert mehrere Transformationsoperationen miteinander.transforms.Resize(): Ändert die Größe des Bildes.transforms.ToTensor(): Konvertiert das Bild in einen PyTorch-Tensor, wobei die Werte normalisiert auf den[0, 1]Bereich.transforms.Normalize(): Normalisiert Bilddaten; Normalisierung ist normalerweise erforderlich, wenn vortrainierte Modelle verwendet werden.
Bilddaten-Augmentierung
Daten-Augmentierungstechniken erhöhen die Vielfalt der Daten, indem sie zufällige Transformationen auf die Trainingsdaten anwenden, wodurch das Modell besser generalisieren kann. Zum Beispiel zufällige Spiegelungen, Drehungen, Ausschnitte usw.
Beispiel
transforms.RandomHorizontalFlip(), # Zufälliges horizontales Spiegeln
transforms.RandomRotation(30), # Zufällige Rotation um 30 Grad
transforms.RandomResizedCrop(128), # Zufälliger Zuschnitt und Größenänderung auf 128x128
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
Diese Datenaugmentierungsmethoden können mit transforms.Compose() kombiniert werden, um sicherzustellen, dass jedes Bild während des Trainings unterschiedliche Transformationen durchläuft.
Laden von Bilddatensätzen
Für Bilddatensätze bietet torchvision.datasets viele gängige Datensätze (wie CIFAR-10, ImageNet, MNIST usw.) sowie Werkzeuge zum Laden von Bilddaten.
Laden des MNIST-Datensatzes:
Beispiel
import torchvision.transforms as transforms
# Vorverarbeitungsoperationen definieren
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,)) # Das Graustufenbild normalisieren
])
# Den MNIST-Datensatz herunterladen und laden
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
# DataLoader erstellen
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
# Über die Trainingsdaten iterieren
for inputs, labels in train_loader:
print(inputs.shape) # Form der Eingabedaten pro Batch
print(labels.shape) # Form der Labels pro Batch
datasets.MNIST()wird den MNIST-Datensatz automatisch herunterladen und laden.transformDer Parameter ermöglicht es uns, die Daten vorzuverarbeiten.train=Trueundtrain=Falserepräsentieren jeweils das Trainingsset und das Testset.
Verwendung mehrerer Datenquellen (Multi-Source-Datensatz)
Wenn Ihr Datensatz aus mehreren Dateien oder mehreren Quellen besteht (z. B. mehreren Bildordnern), können Sie das Laden mehrerer Datenquellen anpassen, indem Sie von der Dataset-Klasse erben.
PyTorch bietet Klassen wie ConcatDataset und ChainDataset, um mehrere Datensätze zu verketten.
Zum Beispiel nehmen wir an, wir haben Daten aus mehreren Bildordnern; wir können sie zu einem Dataset zusammenführen:
Beispiel
# Angenommen, dataset1 und dataset2 sind zwei Dataset-Objekte
combined_dataset = ConcatDataset([dataset1, dataset2])
combined_loader = DataLoader(combined_dataset, batch_size=64, shuffle=True)