| |
| import numpy as np |
| from typing import List |
|
|
|
|
| |
| def lsc(probs: np.ndarray, w: List): |
| r""" |
| Implementation of Label Shift Compensation (LSC) with known target label distribution. |
| Given source domain P(Y_s=i) and P(Y_s=i|X_s=x), target domain P(Y_t=i), |
| estimate target predicted probability q(y|x) on test set. |
| |
| Args: |
| probs: Softmax probability P(Y_s=i|X_s=x) predicted by the classifier, |
| for all samples in validation set (N x C). |
| w: Ratio of Target over Source domain label distribution $ w = P(Y_t=i) / P(Y_s=i) $, |
| Not necessarily normalized to 1. |
| |
| Shapes: |
| * Input: |
| probs: N x C (No. of samples) x (No. of classes), |
| w: C (No. of classes), |
| * Output: |
| pc_probs: N x C (No. of samples) x (No. of classes) |
| |
| |
| For more information see original paper: |
| [2002] "Adjusting the Outputs of a Classifier to New a Priori Probabilities: A Simple Procedure" |
| """ |
| assert len(w) == probs.shape[-1] |
| probs = probs.detach().numpy() |
| pc_probs = normalized(probs * w, axis=-1, order=1) |
|
|
| return pc_probs |
|
|
|
|
| |
| def get_py(probs: np.ndarray, cls_num_list: List[int] = None, mode='soft'): |
| r""" |
| Estimation of source label distribution (normalized) |
| Given source domain P(Y_s=i|X_s=x)=f(x) and No. of sample per-class, |
| estimate P(Y_s=i) or p(\hat{y}=c_i) |
| |
| Args: |
| probs: Softmax probability p(\hat{y}|x) predicted by classifier, |
| over all samples on train set (N x C). |
| cls_num_list: No. of samples in each class (C) |
| mode: Method used to estimate p(\hat{y}=c_i), |
| 'soft' will estimate p(\hat{y}=c_i) \approx \sum^N_j p(\hat{y}=c_i|x_j), |
| 'hard' will estimate p(\hat{y}=c_i) \approx \sum^N_j \mathds{1}(\arg\max_c p(y=c|x_j)=c_i) |
| 'gt' will estimate p(\hat{y}=c_i) \approx P(Y_s=i), which is given by cls_num_list |
| |
| Shapes: |
| * Input: |
| probs: N x C (No. of samples) x (No. of classes), |
| cls_num_list: C (No. of classes), |
| * Output: |
| py: C (No. of classes) |
| |
| Examples: |
| |
| >>> import numpy as np |
| >>> from numpy.linalg import norm |
| >>> class_num = 5; val_set_sample_num = 10 |
| >>> prob = norm(np.random.normal(size=(val_set_sample_num, class_num)), ord=1, axis=-1) |
| >>> num_list = list(range(class_num)) |
| >>> py = get_py(prob, num_list) |
| """ |
| cls_num = probs.shape[-1] |
|
|
| if mode == "soft": |
| py = np.mean(probs, axis=tuple(range(len(np.shape(probs)) - 1))) |
| elif mode == "hard": |
| py = np.bincount(np.argmax(probs, axis=-1), minlength=cls_num) |
| py = py / py.sum() |
| elif mode == 'gt' and cls_num_list is not None: |
| py = np.array(cls_num_list) / cls_num |
| else: |
| raise ValueError("'mode' only support options: 'soft', 'hard', 'gt'") |
|
|
| return py / py.sum() |
|
|
|
|
|
|
| def get_marginal(probs: np.ndarray, cls_num: int, mode: str = 'soft'): |
| r""" |
| Get Marginal Distribution $P(Y=.)$ given $P(Y=.|X=x)$ by summing over x |
| """ |
| assert (mode in ['soft', 'hard']) and probs.shape[-1] == cls_num |
| if mode == 'hard': |
| qz = np.zeros(cls_num) |
| for i in np.argmax(probs, axis=-1): |
| qz[i] += 1. |
| qz = qz / qz.sum() |
| elif mode == 'soft': |
| qz = np.mean(probs, axis=0) |
|
|
| return qz |
|
|
|
|
| def get_confusion_matrix(probs: np.ndarray, |
| labels: List, |
| cls_num: int, |
| mode: str = 'soft'): |
| r""" |
| Get Confusion Matrix of prediction given prediction $P(Y=.|X=x)$ and ground truth label $Y=.$ |
| """ |
| assert (mode in ['soft', 'hard']) and probs.shape[-1] == cls_num |
| cm = np.zeros((cls_num, cls_num)) |
| if mode == 'soft': |
| for i, j in zip(labels, probs): |
| cm[i, :] += j |
| elif mode == 'hard': |
| labels_pred = np.argmax(probs, axis=-1) |
| for i, j in zip(labels, labels_pred): |
| cm[i, j] += 1 |
|
|
| return cm |
|
|
|
|
| def normalized(a, axis=-1, order=2): |
| r""" |
| Prediction Normalization |
| """ |
| l2 = np.atleast_1d(np.linalg.norm(a, order, axis)) |
| l2[l2 == 0] = 1 |
| return a / np.expand_dims(l2, axis) |
|
|
|
|
| def Topk_qy(probs: np.ndarray, cls_num, topk_ratio=0.8, head=0, normalize=True): |
| r""" |
| Get Marginal Distribution $P(Y=.)$ given Topk of $P(Y=.|X=x)$ by summing over x |
| """ |
| assert probs.shape[-1] == cls_num |
|
|
| k = np.clip(int(cls_num * topk_ratio) + head, head + 1, cls_num) |
| qy = np.zeros(cls_num) |
| for x in probs: |
| idx = np.argsort(x)[::-1] |
| idx = idx[head:k] |
| qy[idx] += x[idx] |
|
|
| if normalize: |
| qy = qy / probs.shape[0] |
|
|
| return qy |
|
|
