File size: 9,706 Bytes
a1a1fbf | 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 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 | from typing import Dict
from ...utils import count_tensor_params
from .base_transforms import Transform, DictTransform
import torch
class Normalizer(Transform):
def __init__(self, mean, std, eps=1e-6):
self.mean = mean
self.std = std
self.eps = eps
def transform(self, data):
return (data - self.mean) / (self.std + self.eps)
def inverse_transform(self, data):
return (data * (self.std + self.eps)) + self.mean
def to(self, device):
self.mean = self.mean.to(device)
self.std = self.std.to(device)
def cuda(self):
self.mean = self.mean.cuda()
self.std = self.std.cuda()
def cpu(self):
self.mean = self.mean.cpu()
self.std = self.std.cpu()
class UnitGaussianNormalizer(Transform):
"""
UnitGaussianNormalizer normalizes data to be zero mean and unit std.
Parameters
----------
mean : torch.tensor or None
has to include batch-size as a dim of 1
e.g. for tensors of shape ``(batch_size, channels, height, width)``,
the mean over height and width should have shape ``(1, channels, 1, 1)``
std : torch.tensor or None
eps : float, default is 0
for safe division by the std
dim : int list, default is None
if not None, dimensions of the data to reduce over to compute the mean and std.
.. important::
Has to include the batch-size (typically 0).
For instance, to normalize data of shape ``(batch_size, channels, height, width)``
along batch-size, height and width, pass ``dim=[0, 2, 3]``
mask : torch.Tensor or None, default is None
If not None, a tensor with the same size as a sample,
with value 0 where the data should be ignored and 1 everywhere else
Notes
-----
The resulting mean will have the same size as the input MINUS the specified dims.
If you do not specify any dims, the mean and std will both be scalars.
"""
def __init__(self, mean=None, std=None, eps=1e-7, dim=None, mask=None):
"""Initialize the UnitGaussianNormalizer.
See class docstring for detailed parameter descriptions.
"""
super().__init__()
self.register_buffer("mean", mean)
self.register_buffer("std", std)
self.register_buffer("mask", mask)
self.eps = eps
if mean is not None:
self.ndim = mean.ndim
if isinstance(dim, int):
dim = [dim]
self.dim = dim
self.n_elements = 0
def fit(self, data_batch):
self.update_mean_std(data_batch)
def partial_fit(self, data_batch, batch_size=1):
if 0 in list(data_batch.shape):
return
count = 0
n_samples = len(data_batch)
while count < n_samples:
samples = data_batch[count : count + batch_size]
# print(samples.shape)
# if batch_size == 1:
# samples = samples.unsqueeze(0)
if self.n_elements:
self.incremental_update_mean_std(samples)
else:
self.update_mean_std(samples)
count += batch_size
def update_mean_std(self, data_batch):
self.ndim = data_batch.ndim # Note this includes batch-size
if self.mask is None:
self.n_elements = count_tensor_params(data_batch, self.dim)
self.mean = torch.mean(data_batch, dim=self.dim, keepdim=True)
self.squared_mean = torch.mean(data_batch**2, dim=self.dim, keepdim=True)
self.std = torch.std(data_batch, dim=self.dim, keepdim=True)
else:
batch_size = data_batch.shape[0]
dim = [i - 1 for i in self.dim if i]
shape = [s for i, s in enumerate(self.mask.shape) if i not in dim]
self.n_elements = torch.count_nonzero(self.mask, dim=dim) * batch_size
self.mean = torch.zeros(shape)
self.std = torch.zeros(shape)
self.squared_mean = torch.zeros(shape)
data_batch[:, self.mask == 1] = 0
self.mean[self.mask == 1] = (
torch.sum(data_batch, dim=dim, keepdim=True) / self.n_elements
)
self.squared_mean = (
torch.sum(data_batch**2, dim=dim, keepdim=True) / self.n_elements
)
self.std = torch.std(data_batch, dim=self.dim, keepdim=True)
def incremental_update_mean_std(self, data_batch):
if self.mask is None:
n_elements = count_tensor_params(data_batch, self.dim)
dim = self.dim
else:
dim = [i - 1 for i in self.dim if i]
n_elements = torch.count_nonzero(self.mask, dim=dim) * data_batch.shape[0]
data_batch[:, self.mask == 1] = 0
self.mean = (1.0 / (self.n_elements + n_elements)) * (
self.n_elements * self.mean + torch.sum(data_batch, dim=dim, keepdim=True)
)
self.squared_mean = (1.0 / (self.n_elements + n_elements)) * (
self.n_elements * self.squared_mean
+ torch.sum(data_batch**2, dim=dim, keepdim=True)
)
self.n_elements += n_elements
# 1/(n_i + n_j) * (n_i * sum(x_i^2)/n_i + sum(x_j^2) - (n_i*sum(x_i)/n_i + sum(x_j))^2)
# = 1/(n_i + n_j) * (sum(x_i^2) + sum(x_j^2) - sum(x_i)^2 - 2sum(x_i)sum(x_j) - sum(x_j)^2))
# multiply by (n_i + n_j) / (n_i + n_j + 1) for unbiased estimator
self.std = (
torch.sqrt(self.squared_mean - self.mean**2)
* self.n_elements
/ (self.n_elements - 1)
)
def transform(self, x):
return (x - self.mean) / (self.std + self.eps)
def inverse_transform(self, x):
return x * (self.std + self.eps) + self.mean
def forward(self, x):
return self.transform(x)
def cuda(self):
self.mean = self.mean.cuda()
self.std = self.std.cuda()
return self
def cpu(self):
self.mean = self.mean.cpu()
self.std = self.std.cpu()
return self
def to(self, device):
self.mean = self.mean.to(device)
self.std = self.std.to(device)
return self
@classmethod
def from_dataset(cls, dataset, dim=None, keys=None, mask=None):
"""Return a dictionary of normalizer instances, fitted on the given dataset
Parameters
----------
dataset : pytorch dataset
each element must be a dict {key: sample}
e.g. {'x': input_samples, 'y': target_labels}
dim : int list, default is None
* If None, reduce over all dims (scalar mean and std)
* Otherwise, must include batch-dimensions and all over dims to reduce over
keys : str list or None
if not None, a normalizer is instanciated only for the given keys
"""
for i, data_dict in enumerate(dataset):
if not i:
if not keys:
keys = data_dict.keys()
instances = {key: cls(dim=dim, mask=mask) for key in keys}
for i, data_dict in enumerate(dataset):
for key, sample in data_dict.items():
if key in keys:
instances[key].partial_fit(sample.unsqueeze(0))
return instances
class DictUnitGaussianNormalizer(DictTransform):
"""DictUnitGaussianNormalizer composes
DictTransform and UnitGaussianNormalizer to normalize different
fields of a model output tensor to Gaussian distributions w/
mean 0 and unit variance.
Parameters
----------
normalizer_dict : Dict[str, UnitGaussianNormalizer]
dictionary of normalizers, keyed to fields
input_mappings : Dict[slice]
slices of input tensor to grab per field, must share keys with above
return_mappings : Dict[slice]
_description_
"""
def __init__(
self,
normalizer_dict: Dict[str, UnitGaussianNormalizer],
input_mappings: Dict[str, slice],
return_mappings: Dict[str, slice],
):
assert set(normalizer_dict.keys()) == set(
input_mappings.keys()
), "Error: normalizers and model input fields must be keyed identically"
assert set(normalizer_dict.keys()) == set(
return_mappings.keys()
), "Error: normalizers and model output fields must be keyed identically"
super().__init__(
transform_dict=normalizer_dict,
input_mappings=input_mappings,
return_mappings=return_mappings,
)
@classmethod
def from_dataset(cls, dataset, dim=None, keys=None, mask=None):
"""Return a dictionary of normalizer instances, fitted on the given dataset
Parameters
----------
dataset : pytorch dataset
each element must be a dict {key: sample}
e.g. {'x': input_samples, 'y': target_labels}
dim : int list, default is None
* If None, reduce over all dims (scalar mean and std)
* Otherwise, must include batch-dimensions and all over dims to reduce over
keys : str list or None
if not None, a normalizer is instanciated only for the given keys
"""
for i, data_dict in enumerate(dataset):
if not i:
if not keys:
keys = data_dict.keys()
instances = {key: cls(dim=dim, mask=mask) for key in keys}
for i, data_dict in enumerate(dataset):
for key, sample in data_dict.items():
if key in keys:
instances[key].partial_fit(sample.unsqueeze(0))
return instances
|