PyTorch , framework za mašinsko učenje otvorenog koda , dobija na popularnosti zbog svoje jednostavnosti i lakoće korištenja u aplikacijama dubokog učenja. Stručnjaci modne industrije mogu koristiti PyTorch za identifikaciju trendova i stilova, preporučivanje kombinacija odjeće, pa čak i predviđanje uspjeha stilova u narednim sezonama. U ovom članku ćemo podijeliti kako implementirati jednostavnu analizu mode pomoću PyTorcha.
Definicija problema
Naš cilj je analizirati skup podataka slika, od kojih svaka predstavlja različite odjevne predmete, i koristiti PyTorch za izgradnju modela dubokog učenja koji može kategorizirati ove slike u različite stilove i trendove. Na taj način želimo identificirati istaknute trendove u modnoj industriji i kombinacije odjevnih predmeta koje dobro funkcioniraju.
Postavljanje okruženja
Za početak, potrebno je da imamo instalirane Python i PyTorch na našem sistemu. Pored toga, koristit ćemo torchvision, paket koji sadrži popularne skupove podataka, arhitekture modela i uobičajene transformacije slika za računarski vid.
pip install torch torchvision
Sa instaliranim ovim paketima, sada možemo početi rješavati problem.
Dataset i DataLoader
U ovom članku ćemo koristiti skup podataka FashionMNIST , koji je popularan skup podataka za klasifikaciju slika i dostupan je putem torchvisiona. Skup podataka sadrži 60,000 slika za obuku i 10,000 testnih slika, pri čemu svaka slika predstavlja odjevne predmete iz 10 različitih klasa.
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)
Također moramo postaviti DataLoaders kako bismo efikasno učitali i predprocesirali slike skupa podataka.
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 Architecture
Zatim ćemo definirati naš model dubokog učenja, koji će biti konvolucijska neuronska mreža (CNN) . CNN je pogodna za analizu slika, jer može učiti složene obrasce i strukture unutar modnih podataka.
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()
Obuka i evaluacija
Sada ćemo trenirati model koristeći gubitak unakrsne entropije i stohastički gradijentni pad (SGD) kao naš optimizator. Zatim ćemo procijeniti model na testnom skupu podataka kako bismo provjerili njegovu izvedbu.
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}%")
Pomoću ovog modela i postupka obuke možemo postići impresivnu tačnost na testnom skupu podataka, što nam omogućava prepoznavanje i kategorizaciju različitih stilova i trendova u modnoj industriji.
