मल्टी-आउटपुट मॉडलों का मूल्यांकन और लॉस वेटिंग

इंटरमीडिएट Deep Learning with PyTorch

Michal Oleszak

Machine Learning Engineer

मॉडल मूल्यांकन

acc_alpha = Accuracy(
    task="multiclass", num_classes=30
)
acc_char = Accuracy(
    task="multiclass", num_classes=964
)


net.eval()
with torch.no_grad():
    for images, labels_alpha, labels_char \
    in dataloader_test:
        out_alpha, out_char = net(images)

        _, pred_alpha = torch.max(out_alpha, 1)
        _, pred_char = torch.max(out_char, 1)

        acc_alpha(pred_alpha, labels_alpha)
        acc_char(pred_char, labels_char)

हर आउटपुट के लिए मेट्रिक सेट करें
टेस्ट लोडर पर इटरेट करें और आउटपुट लें
प्रत्येक आउटपुट की प्रेडिक्शन निकालें
एक्यूरेसी मेट्रिक्स अपडेट करें
फाइनल एक्यूरेसी स्कोर निकालें

print(f"Alphabet: {acc_alpha.compute()}")
print(f"Character: {acc_char.compute()}")

Alphabet: 0.3166305720806122
Character: 0.24064336717128754

मल्टी-आउटपुट ट्रेनिंग लूप: पुनरावलोकन

for epoch in range(10):
    for images, labels_alpha, labels_char \
    in dataloader_train:
        optimizer.zero_grad()
        outputs_alpha, outputs_char = net(images)
        loss_alpha = criterion(
          outputs_alpha, labels_alpha
        )
        loss_char = criterion(
          outputs_char, labels_char
        )
        loss = loss_alpha + loss_char
        loss.backward()
        optimizer.step()

दो लॉस: अल्फाबेट और कैरेक्टर के लिए
फाइनल लॉस, दोनों का योग: loss = loss_alpha + loss_char
दोनों क्लासिफिकेशन टास्क समान रूप से महत्वपूर्ण माने गए

टास्क की अलग-अलग महत्ता

कैरेक्टर क्लासिफिकेशन, अल्फाबेट क्लासिफिकेशन से 2 गुना अधिक महत्वपूर्ण

तरीका 1: अधिक महत्वपूर्ण लॉस को 2 के फैक्टर से स्केल करें
```
loss = loss_alpha + loss_char * 2
```
तरीका 2: ऐसे वेट दें जिनका योग 1 हो
```
loss = 0.33 * loss_alpha + 0.67 * loss_char
```

चेतावनी: अलग स्केल पर लॉस

वेटिंग और जोड़ने से पहले लॉस एक ही स्केल पर होने चाहिए
उदाहरण टास्क:
- हाउस प्राइस प्रेडिक्ट करें -> MSE लॉस
- क्वालिटी प्रेडिक्ट करें: low, medium, high -> CrossEntropy लॉस
CrossEntropy आमतौर पर सिंगल-डिजिट में होती है
MSE लॉस दसियों हज़ार तक जा सकती है
मॉडल क्वालिटी असेसमेंट टास्क को नजरअंदाज कर देगा
समाधान: वेटिंग और जोड़ने से पहले दोनों लॉस नॉर्मलाइज़ करें
```
loss_price = loss_price / torch.max(loss_price)
loss_quality = loss_quality / torch.max(loss_quality)
loss = 0.7 * loss_price + 0.3 * loss_quality
```

अभ्यास करते हैं!

इंटरमीडिएट Deep Learning with PyTorch