ಪೈಟೋರ್ಚ್, ಒಂದು ಮುಕ್ತ ಮೂಲ ಯಂತ್ರ ಕಲಿಕೆಯ ಚೌಕಟ್ಟು, ಆಳವಾದ ಕಲಿಕೆಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಅದರ ಸರಳತೆ ಮತ್ತು ಬಳಕೆಯ ಸುಲಭತೆಗಾಗಿ ಜನಪ್ರಿಯತೆಯನ್ನು ಗಳಿಸುತ್ತಿದೆ. ಫ್ಯಾಷನ್ ಉದ್ಯಮ ಪ್ರವೃತ್ತಿಗಳು ಮತ್ತು ಶೈಲಿಗಳನ್ನು ಗುರುತಿಸಲು, ಬಟ್ಟೆ ಸಂಯೋಜನೆಗಳನ್ನು ಶಿಫಾರಸು ಮಾಡಲು ಮತ್ತು ಮುಂಬರುವ ಋತುಗಳಲ್ಲಿ ಶೈಲಿಗಳ ಯಶಸ್ಸನ್ನು ಊಹಿಸಲು ತಜ್ಞರು PyTorch ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಈ ಲೇಖನದಲ್ಲಿ, ಸರಳವನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಎಂದು ನಾವು ಹಂಚಿಕೊಳ್ಳುತ್ತೇವೆ ಫ್ಯಾಷನ್ ವಿಶ್ಲೇಷಣೆ PyTorch ಬಳಸಿ.
ಸಮಸ್ಯೆ ವ್ಯಾಖ್ಯಾನ
ಚಿತ್ರಗಳ ಡೇಟಾಸೆಟ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು ನಮ್ಮ ಉದ್ದೇಶವಾಗಿದೆ, ಪ್ರತಿಯೊಂದೂ ವಿವಿಧ ಬಟ್ಟೆ ವಸ್ತುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಮತ್ತು ಈ ಚಿತ್ರಗಳನ್ನು ವಿಭಿನ್ನ ಶೈಲಿಗಳು ಮತ್ತು ಪ್ರವೃತ್ತಿಗಳಾಗಿ ವರ್ಗೀಕರಿಸಬಹುದಾದ ಆಳವಾದ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು PyTorch ಅನ್ನು ಬಳಸುವುದು. ಹಾಗೆ ಮಾಡುವ ಮೂಲಕ, ಫ್ಯಾಷನ್ ಉದ್ಯಮದಲ್ಲಿನ ಪ್ರಮುಖ ಪ್ರವೃತ್ತಿಗಳು ಮತ್ತು ಒಟ್ಟಿಗೆ ಕೆಲಸ ಮಾಡುವ ಉಡುಪುಗಳ ಸಂಯೋಜನೆಯನ್ನು ಗುರುತಿಸುವ ಗುರಿಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ.
ಪರಿಸರವನ್ನು ಸ್ಥಾಪಿಸುವುದು
ಪ್ರಾರಂಭಿಸಲು, ನಾವು ಹೊಂದಿರಬೇಕು ಪೈಥಾನ್ ಮತ್ತು ಪೈಟೋರ್ಚ್ ನಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ನಾವು ಟಾರ್ಚ್‌ವಿಷನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಜನಪ್ರಿಯ ಡೇಟಾಸೆಟ್‌ಗಳು, ಮಾಡೆಲ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳು ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ದೃಷ್ಟಿಗಾಗಿ ಸಾಮಾನ್ಯ ಇಮೇಜ್ ರೂಪಾಂತರಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ಯಾಕೇಜ್.
pip install torch torchvision
ಈ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನಾವು ಈಗ ಸಮಸ್ಯೆಯನ್ನು ನಿಭಾಯಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು.
ಡೇಟಾಸೆಟ್ ಮತ್ತು ಡಾಟಾಲೋಡರ್
ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಬಳಸುತ್ತೇವೆ FashionMNIST ಡೇಟಾಸೆಟ್, ಇದು ಇಮೇಜ್ ವರ್ಗೀಕರಣಕ್ಕಾಗಿ ಜನಪ್ರಿಯ ಡೇಟಾಸೆಟ್ ಆಗಿದೆ ಮತ್ತು ಟಾರ್ಚ್‌ವಿಷನ್ ಮೂಲಕ ಲಭ್ಯವಿದೆ. ಡೇಟಾಸೆಟ್ 60,000 ತರಬೇತಿ ಚಿತ್ರಗಳನ್ನು ಮತ್ತು 10,000 ಪರೀಕ್ಷಾ ಚಿತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಪ್ರತಿ ಚಿತ್ರವು 10 ವಿವಿಧ ವರ್ಗಗಳ ಬಟ್ಟೆ ವಸ್ತುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
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)
ನಾವು ಕೂಡ ಹೊಂದಿಸಬೇಕಾಗಿದೆ ಡೇಟಾ ಲೋಡ್‌ಗಳು ಡೇಟಾಸೆಟ್ ಚಿತ್ರಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಪೂರ್ವ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು.
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)
ಮಾದರಿ ವಾಸ್ತುಶಿಲ್ಪ
ಮುಂದೆ, ನಾವು ನಮ್ಮ ಆಳವಾದ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಅದು a ಕನ್ವಲ್ಯೂಷನಲ್ ನ್ಯೂರಲ್ ನೆಟ್‌ವರ್ಕ್ (CNN). ಚಿತ್ರಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು CNN ಸೂಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಫ್ಯಾಶನ್ ಡೇಟಾದೊಳಗೆ ಸಂಕೀರ್ಣ ಮಾದರಿಗಳು ಮತ್ತು ರಚನೆಗಳನ್ನು ಕಲಿಯಬಹುದು.
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()
ತರಬೇತಿ ಮತ್ತು ಮೌಲ್ಯಮಾಪನ
ಈಗ, ನಾವು ಕ್ರಾಸ್-ಎಂಟ್ರೊಪಿ ಲಾಸ್ ಮತ್ತು ಸ್ಟೊಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ (SGD) ಅನ್ನು ನಮ್ಮ ಆಪ್ಟಿಮೈಜರ್ ಆಗಿ ಬಳಸಿಕೊಂಡು ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುತ್ತೇವೆ. ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತೇವೆ.
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}%")
ಈ ಮಾದರಿ ಮತ್ತು ತರಬೇತಿ ವಿಧಾನದೊಂದಿಗೆ, ನಾವು ಪ್ರಭಾವಶಾಲಿ ಸಾಧಿಸಬಹುದು ನಿಖರತೆ ಪರೀಕ್ಷಾ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ, ಫ್ಯಾಷನ್ ಉದ್ಯಮದಲ್ಲಿನ ವಿವಿಧ ಶೈಲಿಗಳು ಮತ್ತು ಪ್ರವೃತ್ತಿಗಳನ್ನು ಗುರುತಿಸಲು ಮತ್ತು ವರ್ಗೀಕರಿಸಲು ನಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
