File size: 6,105 Bytes
2eb3475 | 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 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | import torch
import numpy as np
from sklearn.decomposition import KernelPCA
from tqdm import tqdm
from sklearn.covariance import MinCovDet
DOUBLE_INFO = torch.finfo(torch.double)
JITTERS = [10**exp for exp in range(-15, 0, 1)]
def mahalanobis_distance_with_known_centroids_sigma_inv(
centroids, centroids_mask, sigma_inv, eval_features
):
"""
- This function takes in centroids, centroids_mask, sigma_inv, and eval_features.
- tensor of Mahalanobis distances is returned.
"""
# step 1: calculate the difference (diff) between each evaluation feature and each centroid by subtracting the centoids from the features.
diff = eval_features.unsqueeze(1) - centroids.unsqueeze(
0
) # bs (b), num_labels (c / s), dim (d / a)
# step 2: the Mahalanobis distance is computed using the formula: sqrt(diff @ sigmainv @ diff),
# where diff is reshaped to match the dimensions of sigmainv.
dists = torch.sqrt(torch.einsum("bcd,da,bsa->bcs", diff, sigma_inv, diff))
device = dists.device
# step 3: obtain a tensor of distances for each evaluation feature and centroid pair.
dists = torch.stack([torch.diag(dist).cpu() for dist in dists], dim=0)
# If centroids_mask is not None, the distances corresponding to masked centroids are filled with infinity.
if centroids_mask is not None:
dists = dists.masked_fill_(centroids_mask, float("inf")).to(device)
return dists # np.min(dists, axis=1)
def mahalanobis_distance_marginal(
train_features, train_labels, eval_features, centroids=None, covariance=None
):
if centroids is None:
centroids = compute_centroids(train_features, train_labels, class_cond=False)
if covariance is None:
covariance = compute_covariance(
centroids, train_features, train_labels, class_cond=False
)
diff = eval_features - centroids[None, :]
dists = np.matmul(np.matmul(diff, covariance), diff.T)
return np.diag(dists)
def compute_centroids(train_features, train_labels, class_cond=True):
if class_cond:
centroids = []
for label in np.sort(np.unique(train_labels)):
centroids.append(train_features[train_labels == label].mean(axis=0))
return np.asarray(centroids)
else:
return train_features.mean(axis=0)
def compute_covariance(centroids, train_features, train_labels, class_cond=True):
cov = np.zeros((train_features.shape[1], train_features.shape[1]))
if class_cond:
for c, mu_c in tqdm(enumerate(centroids)):
for x in train_features[train_labels == c]:
d = (x - mu_c)[:, None]
cov += d @ d.T
else:
for x in train_features:
d = (x - centroids)[:, None]
cov += d @ d.T
cov /= train_features.shape[0]
try:
sigma_inv = np.linalg.inv(cov)
except:
sigma_inv = np.linalg.pinv(cov)
print("Compute pseudo-inverse matrix")
return sigma_inv
def mahalanobis_distance_relative(
train_features,
train_labels,
eval_features,
centroids=None,
covariance=None,
train_centroid=None,
train_covariance=None,
):
if centroids is None:
centroids = compute_centroids(train_features, train_labels)
if covariance is None:
covariance = compute_covariance(centroids, train_features, train_labels)
diff = eval_features[:, None, :] - centroids[None, :, :]
dists = np.matmul(np.matmul(diff, covariance), diff.transpose(0, 2, 1))
dists = np.asarray([np.diag(dist) for dist in dists])
md_marginal = mahalanobis_distance_marginal(
train_features, train_labels, eval_features, train_centroid, train_covariance
)
return np.min(dists - md_marginal[:, None], axis=1)
def mahalanobis_distance(
train_features,
train_labels,
eval_features,
centroids=None,
covariance=None,
return_full=False,
):
if centroids is None:
centroids = compute_centroids(train_features, train_labels)
if covariance is None:
covariance = compute_covariance(centroids, train_features, train_labels)
diff = eval_features[:, None, :] - centroids[None, :, :]
dists = np.matmul(np.matmul(diff, covariance), diff.transpose(0, 2, 1))
dists = np.asarray([np.diag(dist) for dist in dists])
if return_full:
return dists
else:
return np.min(dists, axis=1)
def MCD_covariance(X, y=None, label=None, seed=42, support_fraction=None):
try:
if label is None:
cov = MinCovDet(random_state=seed, support_fraction=support_fraction).fit(X)
else:
cov = MinCovDet(random_state=seed, support_fraction=support_fraction).fit(X[y == label])
except ValueError:
print(
"****************Try fitting covariance with support_fraction=0.9 **************"
)
try:
if label is None:
cov = MinCovDet(random_state=seed, support_fraction=0.9).fit(X)
else:
cov = MinCovDet(random_state=seed, support_fraction=0.9).fit(
X[y == label]
)
except ValueError:
print(
"****************Try fitting covariance with support_fraction=1.0 **************"
)
if label is None:
cov = MinCovDet(random_state=seed, support_fraction=1.0).fit(X)
else:
cov = MinCovDet(random_state=seed, support_fraction=1.0).fit(
X[y == label]
)
return cov
def rde_distance(
train_features,
test_features,
n_components=256,
support_fraction=None
):
pca = KernelPCA(n_components=n_components, kernel="rbf", random_state=42)
train_features_pca = pca.fit_transform(train_features.float().cpu().numpy())
test_features_pca = pca.transform(test_features.float().cpu().numpy())
mcd = MCD_covariance(train_features_pca, seed=42, support_fraction=support_fraction)
rde_distance = mcd.mahalanobis(test_features_pca)
return rde_distance |