File size: 2,560 Bytes
9e56db5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
import torch
import torch.nn.functional as F
def lsc_torch(probs: torch.Tensor, w: torch.Tensor):
"""
GPU-compatible LSC implementation
probs: Tensor [N, C]
w: Tensor [C]
"""
assert probs.shape[-1] == w.shape[0], "Shape mismatch"
weighted_probs = probs * w
pc_probs = F.normalize(weighted_probs, p=1, dim=-1)
return pc_probs
def get_py_torch(probs: torch.Tensor, cls_num_list=None, mode='soft'):
"""
GPU-compatible estimation of P(Y_s=i)
probs: Tensor [N, C]
"""
cls_num = probs.shape[-1]
if mode == "soft":
py = torch.mean(probs, dim=0)
elif mode == "hard":
preds = torch.argmax(probs, dim=-1)
py = torch.bincount(preds, minlength=cls_num).float()
py = py / py.sum()
elif mode == 'gt' and cls_num_list is not None:
py = torch.tensor(cls_num_list, dtype=torch.float32, device=probs.device)
py = py / py.sum()
else:
raise ValueError("mode must be 'soft', 'hard', or 'gt'")
return py
def get_marginal_torch(probs: torch.Tensor, cls_num: int, mode='soft'):
assert probs.shape[-1] == cls_num
if mode == 'hard':
pred = torch.argmax(probs, dim=-1)
qz = torch.bincount(pred, minlength=cls_num).float()
qz = qz / qz.sum()
elif mode == 'soft':
qz = torch.mean(probs, dim=0)
return qz
def get_confusion_matrix_torch(probs: torch.Tensor, labels: torch.Tensor, cls_num: int, mode='soft'):
"""
probs: Tensor [N, C]
labels: Tensor [N] (long)
returns: [cls_num, cls_num] confusion matrix
"""
cm = torch.zeros((cls_num, cls_num), device=probs.device)
if mode == 'soft':
for i in range(len(labels)):
cm[labels[i]] += probs[i]
elif mode == 'hard':
pred = torch.argmax(probs, dim=-1)
for i in range(len(labels)):
cm[labels[i], pred[i]] += 1
return cm
def normalized_torch(a: torch.Tensor, axis=-1, order=2):
norm = torch.norm(a, p=order, dim=axis, keepdim=True)
norm[norm == 0] = 1.0
return a / norm
def topk_qy_torch(probs: torch.Tensor, cls_num: int, topk_ratio=0.8, head=0, normalize=True):
"""
probs: Tensor [N, C]
return: Tensor [C]
"""
N, C = probs.shape
k = max(min(int(cls_num * topk_ratio) + head, cls_num), head + 1)
qy = torch.zeros(cls_num, device=probs.device)
topk_vals, topk_indices = torch.topk(probs, k=k, dim=1)
for i in range(N):
qy[topk_indices[i][head:]] += topk_vals[i][head:]
if normalize:
qy = qy / N
return qy
|