Vyřešeno: pytorch_starting

Poslední aktualizace: 09/11/2023
Autor: Python SourceTrail

pytorch_starting Móda není v neustále se vyvíjejícím světě technologií žádnou neznámou a jako programátoři, nadšenci a módní experti je nezbytné zůstat na špici. Jedním takovým způsobem je hluboké učení s PyTorch, rámcem strojového učení, který je lehký, snadno použitelný a vysoce použitelný pro analýzu moderní módy. V tomto článku se ponoříme do toho, jak nám PyTorch může pomoci analyzovat a porozumět módním trendům, počínaje úvodem, řešením problému s PyTorchem a podrobným průvodcem krok za krokem, který vám pomůže jej co nejlépe využít. Tak pojďme do toho!

PyTorch , open-source framework pro strojové učení , si získává na popularitě díky své jednoduchosti a snadnému použití v aplikacích hlubokého učení. Odborníci z módního průmyslu mohou PyTorch využít k identifikaci trendů a stylů, doporučování kombinací oblečení a dokonce i k předpovídání úspěchu stylů v nadcházejících sezónách. V tomto článku se podělíme o to, jak implementovat jednoduchou analýzu módy pomocí PyTorchu.

Definice problému

Naším cílem je analyzovat datovou sadu obrázků, z nichž každý představuje různé oděvní položky, a pomocí PyTorch vytvořit model hlubokého učení, který dokáže tyto obrázky kategorizovat do různých stylů a trendů. Tímto způsobem se snažíme identifikovat významné trendy v módním průmyslu a kombinace oděvů, které spolu dobře ladí.

Nastavení prostředí

Pro začátek budeme potřebovat na našem systému nainstalovaný Python a PyTorch . Dále budeme používat torchvision, balíček obsahující oblíbené datové sady, architektury modelů a běžné transformace obrazu pro počítačové vidění.

pip install torch torchvision

S těmito nainstalovanými balíčky můžeme nyní začít problém řešit.

Dataset a DataLoader

V tomto článku použijeme datovou sadu FashionMNIST , což je populární datová sada pro klasifikaci obrázků dostupná prostřednictvím aplikace Torchvision. Datová sada obsahuje 60 000 trénovacích obrázků a 10 000 testovacích obrázků, přičemž každý obrázek představuje oděvní položky 10 různých tříd.

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)

Také musíme nastavit DataLoadery pro efektivní načítání a předzpracování obrázků z datové sady.

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)

Architektura modelu

Dále si definujeme náš model hlubokého učení, kterým bude konvoluční neuronová síť (CNN) . CNN je vhodná pro analýzu obrázků, protože se dokáže učit složité vzory a struktury v módních datech.

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()

Školení a hodnocení

Nyní budeme model trénovat pomocí Cross-Entropy Loss a Stochastic Gradient Descent (SGD) jako našeho optimalizátoru. Poté vyhodnotíme model na testovací datové sadě, abychom zkontrolovali jeho výkon.

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}%")

S tímto modelem a trénovacím postupem můžeme dosáhnout působivé přesnosti na testovací datové sadě, což nám umožňuje rozpoznávat a kategorizovat různé styly a trendy v módním průmyslu.

Související příspěvky: