Opgelost: pytorch_starting

Laatste update: 09/11/2023
Auteur: Python BronTrail

pytorch_start Mode is geen onbekende in de steeds evoluerende wereld van technologie, en als programmeurs, enthousiastelingen en mode-experts is het essentieel om voorop te blijven lopen. Een van die manieren is door middel van diep leren met PyTorch, een machine learning-framework dat licht, gebruiksvriendelijk en zeer toepasbaar is voor moderne mode-analyse. In dit artikel gaan we dieper in op hoe PyTorch ons kan helpen bij het analyseren en begrijpen van modetrends, beginnend met een inleiding, het oplossen van een probleem met PyTorch en een gedetailleerde stapsgewijze handleiding om u te helpen er het beste uit te halen. Dus laten we erin springen!

PyTorch, een open source raamwerk voor machine learning, wint aan populariteit vanwege zijn eenvoud en gebruiksgemak in deep learning-toepassingen. Mode-industrie experts kunnen PyTorch gebruiken om trends en stijlen te identificeren, kledingcombinaties aan te bevelen en zelfs het succes van stijlen in de komende seizoenen te voorspellen. In dit artikel zullen we delen hoe u een eenvoudig kunt implementeren mode analyse met behulp van PyTorch.

Probleem definitie

Ons doel is om een ​​dataset van afbeeldingen te analyseren, die elk verschillende kledingstukken vertegenwoordigen, en PyTorch te gebruiken om een ​​diepgaand leermodel te bouwen dat deze afbeeldingen in verschillende stijlen en trends kan categoriseren. Door dit te doen, willen we prominente trends in de mode-industrie en combinaties van kledingstukken die goed bij elkaar passen, identificeren.

De omgeving instellen

Om te beginnen, zullen we moeten hebben Python en PyTorch geïnstalleerd op ons systeem. Daarnaast zullen we torchvision gebruiken, een pakket met populaire datasets, modelarchitecturen en algemene beeldtransformaties voor computervisie.

pip install torch torchvision

Nu deze pakketten zijn geïnstalleerd, kunnen we beginnen met het aanpakken van het probleem.

Dataset en DataLoader

In dit artikel gebruiken we de ModeMNIST dataset, een populaire dataset voor beeldclassificatie en beschikbaar via torchvision. De dataset bevat 60,000 trainingsafbeeldingen en 10,000 testafbeeldingen, waarbij elke afbeelding kledingstukken van de 10 verschillende klassen vertegenwoordigt.

from torchvision import datasets, transforms

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_data = datasets.FashionMNIST(root="./data", train=True, download=True, transform=transform)
test_data = datasets.FashionMNIST(root="./data", train=False, download=True, transform=transform)

We moeten ook instellen Gegevensladers om de afbeeldingen van de dataset efficiënt te laden en voor te verwerken.

from torch.utils.data import DataLoader

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64, shuffle=False)

Model Architectuur

Vervolgens zullen we ons deep learning-model definiëren, dat een Convolutioneel neuraal netwerk (CNN). Een CNN is geschikt voor het analyseren van beelden, omdat het complexe patronen en structuren binnen de modegegevens kan leren.

import torch.nn as nn
import torch.nn.functional as F

class FashionModel(nn.Module):
    def __init__(self):
        super(FashionModel, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64*7*7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64*7*7)
        x = F.relu(self.fc1(x))
        x = F.log_softmax(self.fc2(x), dim=1)
        return x

model = FashionModel()

Training en evaluatie

Nu gaan we het model trainen met Cross-Entropy Loss en Stochastic Gradient Descent (SGD) als onze optimizer. Vervolgens evalueren we het model op de testdataset om de prestaties te controleren.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

epochs = 10
for epoch in range(epochs):
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f"Epoch {epoch + 1}, Loss: {running_loss / len(train_loader)}")

correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Accuracy: {correct / total * 100}%")

Met dit model en deze trainingsprocedure kunnen we een indrukwekkend resultaat behalen nauwkeurigheid op de testdataset, waardoor we de verschillende stijlen en trends in de mode-industrie kunnen herkennen en categoriseren.

Gerelateerde berichten: