def simulate(self, batch_size, dt, seq_len, verbose=False): """ conducts simulation of the process with model parameters input: batch_size - int, number of sequences to generate dt - Tensor like, size = (batch_size), delta time during the generation (Poisson = Poisson(lambda*dt)) seq_len - int, sequence length verbose - bool, if True, print the info during generation output: sequences - torch.Tensor, size = (batch_size, seq_len, num_classes), simulated data """ with torch.no_grad(): self.eval() # result template res = torch.zeros(batch_size, seq_len, 1 + self.num_classes) # initial hidden and cell state preprocessing hidden0 = self.hidden0[:, None, :] cell0 = self.cell0[:, None, :] # iterations over batch for b in range(batch_size): if verbose: print('Generating batch {}/{}'.format(b + 1, batch_size)) # iteration over sequence for s in range(seq_len): if verbose and s % 100 == 0: print('>>> Generating sequence step {}/{}'.format( s + 1, seq_len)) # first iteration doesn't depend on the history and should be processed independently if s == 0: # computing lambda if self.bidir: h0 = hidden0[-3:, :, :].reshape(-1) else: h0 = hidden0[-1, :, :].reshape(-1) lambdas = self.f(h0 @ self.W) # simulation res[b, s, 1:] = torch.poisson(lambdas * dt[b]) res[b, s, 0] = dt[b] hidden = hidden0.clone() cell = cell0.clone() else: # computing lambda o, (hidden, cell) = self.lstm(res[b, s - 1][None, None, :], (hidden, cell)) lambdas = self.f(o[0, -1, :] @ self.W) # simulation res[b, s, 1:] = torch.poisson(lambdas * dt[b]) res[b, s, 0] = dt[b] return res
def add_poisson_gaussian_noise(x, a, b): if a == 0: z = x + math.sqrt(b) * torch.randn(*x.shape) else: chi = 1 / a z = torch.poisson(chi * x) / chi + math.sqrt(b) * torch.randn(*x.shape) return torch.max(torch.zeros_like(z), torch.min(torch.ones_like(z), z))
def infill_and_mask_tokens(self, input_ids): """ Prepares masked tokens input and label pairs for text-infilled MLM. :param (torch.Tensor) input_ids: tensor with shape (B, S), contains sequences :return: (torch.Tensor, torch.Tensor) input_ids, labels """ # In masked language modeling, the labels are the input itself (i.e. self-supervision) labels = input_ids.clone() # Initialize the masked indices with all zeros masked_indices = torch.full(labels.shape, fill_value=0.0, dtype=torch.bool) # Do for each example in batch for i in range(labels.shape[0]): # Start from the beginning of the sequence; j is the num. of tokens processed j = 0 while j < labels.shape[1]: # Sample a span_length (i.e. length of span of tokens to be masked) span_length = torch.poisson(torch.tensor(self.mean_span_length, dtype=torch.float)).long().item() if span_length >= labels.shape[1]: span_length = self.mean_span_length # Reserve a context of length to surround the span to be masked context_length = int(span_length / self.mask_probability) # Sample a starting point and mask tokens in the computed span start_index = j + torch.randint(context_length-span_length + 1, (1,)).item() if start_index >= labels.shape[1]: break # Simply replace all tokens in the span with [MASK] tokens if 'spanbert' if self.mask_strategy == 'spanbert': masked_indices[i, start_index: start_index+span_length] = 1 # Replace all tokens in the span with a single [MASK] token and add n-1 [PAD] tokens elif self.mask_strategy == 'bart': masked_indices[i, start_index] = 1 input_ids[i, start_index+1:] = torch.cat( [input_ids[i, start_index+span_length:], torch.full(size=(span_length-1, ), fill_value=self.tokenizer.pad_token_id, dtype=torch.long)] ) # Update num. tokens processed j += context_length # Store all of the special indices, those set by self.special_token_ids, in a mask all_special_indices = torch.zeros(labels.shape).bool() # Check if certain other token (e.g. [PAD], [UNK], etc.) exists in the tokenizer for special_token_id in self.special_token_ids: if special_token_id: # Get the related indices in the input IDs special_indices = labels.eq(special_token_id) all_special_indices |= special_indices # Fill in special indices with 0.0 - we don't want them masked masked_indices.masked_fill_(mask=special_indices, value=0.0) # Mask the selected indices in input IDs and and set everything else to a large, negative # number in labels to ensure that loss is not computed on them input_ids[masked_indices] = self.tokenizer.mask_token_id if self.mask_strategy == 'spanbert': labels[~masked_indices] = self.nomask_id elif self.mask_strategy == 'bart': labels[all_special_indices] = self.nomask_id return input_ids, labels
def test_abp_global_search(cfg, clean, noisy_img=None): # -- create vars for search -- N, B, C, H, W = clean.shape PS = cfg.patchsize NH = cfg.nh_size # -- setup for best_indices -- patches = tile_burst_patches(clean, PS, NH) # -- add noise for testing -- if noisy_img is None: alpha = 4. noisy = torch.poisson(alpha * (patches + 0.5)) / alpha else: noisy = tile_burst_patches(noisy_img, PS, NH) # -- run search -- scores, indices = test_run_abp_patch_search_exhaustive_global_dynamics( noisy, patches, PS, NH) indices.cuda(non_blocking=True) # -- recover aligned burst images -- aligned = aligned_burst_image_from_indices_global_dynamics( patches, np.arange(N), indices) ave = torch.mean(aligned, dim=0) return indices, ave, aligned
def sample(self, sample_shape=torch.Size()): shape = self._extended_shape(sample_shape) with torch.no_grad(): mask = torch.bernoulli(self.gate.expand(shape)).byte() samples = torch.poisson(self.rate.expand(shape)) samples.masked_fill_(mask, 0.) return samples
def add_noise(image, noise_mode=''): """ ref: https://github.com/scikit-image/scikit-image/blob/master/skimage/util/noise.py#L8 :param image: :return noisy image: """ if torch.min(image) < 0: low_clip = -1. else: low_clip = 0. noise_mode = noise_mode.lower() if noise_mode == 'gaussian': mean = 0.0 var = 0.01 noise_map = image.clone().normal_(mean, var**0.5) out = image + noise_map elif noise_mode == 'poisson': # Determine unique values in image & calculate the next power of two vals = torch.tensor(len(torch.unique(image)) * 1.) vals = 2**torch.ceil(torch.log2(vals)) # Ensure image is exclusively positive if low_clip == -1.: old_max = torch.max(image) image = (image + 1.) / (old_max + 1.) # Generating noise for each unique value in image. out = torch.poisson(image * vals) / float(vals) # Return image to original range if input was signed if low_clip == -1.: out = out * (old_max + 1.) - 1. else: raise NotImplementedError out = torch.clamp(out, low_clip, 1.0) return out
def __call__(self,pic): pic_bw = tvF.rgb_to_grayscale(pic,1) poisson_pic = torch.poisson(self.alpha*pic_bw,generator=self.seed)/self.alpha if pic.shape[-3] == 3: repeat = [1 for i in pic.shape] repeat[-3] = 3 poisson_pic = poisson_pic.repeat(*(repeat)) return poisson_pic
def shot_noise(x: Tensor, severity: int = 1) -> Tensor: """Applys shot noise.""" imagenet_rate_mult = [60, 25, 12, 5, 3] cifar_rate_mult = [500, 250, 100, 75, 50] rate_mult = interpolate_severity(x, cifar_rate_mult, imagenet_rate_mult, severity) # very likely the clamp is not needed, but numerical stability... return (torch.poisson(x * rate_mult) / rate_mult).clamp(min=0.0, max=1.0)
def generate_poisson_noise_pt(img, scale=1.0, gray_noise=0): """Generate a batch of poisson noise (PyTorch version) Args: img (Tensor): Input image, shape (b, c, h, w), range [0, 1], float32. scale (float | Tensor): Noise scale. Number or Tensor with shape (b). Default: 1.0. gray_noise (float | Tensor): 0-1 number or Tensor with shape (b). 0 for False, 1 for True. Default: 0. Returns: (Tensor): Returned noisy image, shape (b, c, h, w), range[0, 1], float32. """ b, _, h, w = img.size() if isinstance(gray_noise, (float, int)): cal_gray_noise = gray_noise > 0 else: gray_noise = gray_noise.view(b, 1, 1, 1) cal_gray_noise = torch.sum(gray_noise) > 0 if cal_gray_noise: img_gray = rgb_to_grayscale(img, num_output_channels=1) # round and clip image for counting vals correctly img_gray = torch.clamp((img_gray * 255.0).round(), 0, 255) / 255. # use for-loop to get the unique values for each sample vals_list = [len(torch.unique(img_gray[i, :, :, :])) for i in range(b)] vals_list = [2**np.ceil(np.log2(vals)) for vals in vals_list] vals = img_gray.new_tensor(vals_list).view(b, 1, 1, 1) out = torch.poisson(img_gray * vals) / vals noise_gray = out - img_gray noise_gray = noise_gray.expand(b, 3, h, w) # always calculate color noise # round and clip image for counting vals correctly img = torch.clamp((img * 255.0).round(), 0, 255) / 255. # use for-loop to get the unique values for each sample vals_list = [len(torch.unique(img[i, :, :, :])) for i in range(b)] vals_list = [2**np.ceil(np.log2(vals)) for vals in vals_list] vals = img.new_tensor(vals_list).view(b, 1, 1, 1) out = torch.poisson(img * vals) / vals noise = out - img if cal_gray_noise: noise = noise * (1 - gray_noise) + noise_gray * gray_noise if not isinstance(scale, (float, int)): scale = scale.view(b, 1, 1, 1) return noise * scale
def poisson_noise_loader(self, size, numpyData=False, seed=-1): if seed != -1: if numpyData: np.random.seed(self.data_seed) else: torch.random.manual_seed(self.data_seed) if numpyData: # more data means all data after #0 are signal cases data = [] if len(self.mean_data) > 2 and self.signal_no_signal: labels = np.random.randint(2, size=size) for l in labels: if l == 0: data.append(np.random.poisson(self.mean_data[l])) else: selector = np.random.randint(1, len(self.mean_data)) data.append(np.random.poisson( self.mean_data[selector])) else: labels = np.random.randint(len(self.mean_data), size=size) for l in labels: data.append(np.random.poisson(self.mean_data[l])) data = np.stack(data) return data, labels else: data = [] if len(self.mean_data) > 2 and self.signal_no_signal: labels = torch.randint(2, (size, )).type(torch.long) for l in labels: if l == 0: data.append(torch.poisson(self.mean_data[l])) else: selector = np.random.randint(1, len(self.mean_data)) data.append(torch.poisson(self.mean_data[selector])) else: labels = torch.randint(len(self.mean_data), (size, )).type(torch.long) for l in labels: data.append(torch.poisson(self.mean_data[l])) data = torch.stack(data) return data, labels
def span_dropout(x, dropout=0.15): if len(x) == 1: return x span_size = torch.poisson(torch.ones( 1, 1)).long().item() #random.choice(range(min(4, len(x)))) if span_size == 0 or span_size > (len(x) - 1): return x mask_ix = random.choice(range(len(x))) return torch.cat([ x[:mask_ix], torch.zeros((1, x.shape[-1])), x[mask_ix + span_size:], ]), (mask_ix, span_size)
def test_PoissonNLLLoss_direct(reduction, log_input, full): torch.manual_seed(42) model = torch.nn.PoissonNLLLoss(log_input, full, reduction=reduction) poptorch_model = poptorch.inferenceModel(model) target = torch.poisson(torch.rand(10) * 5) input = torch.empty(10).uniform_() native_out = model(input, target) poptorch_out = poptorch_model(input, target) torch.testing.assert_allclose(native_out, poptorch_out)
def add_noise(image, mode='poisson', psnr=25, noisy_per_clean=2, clip=False): """This function is called to create noisy images, after getting minibatch of clean images from dataloader. Works well for non-saturating images, uint8. Different implementation of scaling of pixel values for the mean of Poisson noise. References: https://github.com/scikit-image/scikit-image/blob/master/skimage/util/noise.py https://www.mathworks.com/help/images/ref/imnoise.html#mw_226e1fb2-f53a-4e49-9bb1-6b167fc2eac1 http://reference.wolfram.com/language/ref/ImageEffect.html https://imagej.nih.gov/ij/plugins/poisson-noise.html Args: image (torch.Tensor): image after `torchvision.transforms.ToTensor`, range [0.0, 1.0], (B, C, H, W) mode (str): Default `Poisson`, other kinds of noise on the way... psnr (float): Peak-SNR in DB. If it is list of size 2, then uniformly select one psnr from this range noisy_per_clean (int): return number of noisy images per clean image clip (bool): clip the noisy output or not """ if mode == 'poisson': if image.dtype == torch.uint8: max_val = 255 elif image.dtype == torch.int16: max_val = 32767 if image.max() > 4095 else 4095 else: raise TypeError('image data type is expected to be either uint8 ' \ 'or int16, but got {}'.format(image.dtype)) if noisy_per_clean > 1: image = image.repeat(noisy_per_clean, 1, 1, 1) image = image.float() if isinstance(psnr, (list, tuple)): assert len(psnr) == 2, 'please specify the range of PSNR using ' \ 'only two numbers' # randomly select noise level for each channel psnr = torch.randn(image.shape[0]).uniform_(psnr[0], psnr[1]).to( image.device) scale = 10**(psnr / 10) * image.view(image.size(0), -1).mean(1) / max_val**2 scale = scale.view(image.size(0), 1, 1, 1) noisy = torch.poisson(image * scale) / scale return torch.clamp(noisy, 0., max_val) if clip else noisy else: raise NotImplementedError('Other noise mode to be implemented')
def _transform( self, x: "torch.Tensor", y: Optional["torch.Tensor"], **kwargs) -> Tuple["torch.Tensor", Optional["torch.Tensor"]]: """ Transformation of an image with randomly sampled shot (Poisson) noise. :param x: Input samples. :param y: Label of the samples `x`. :return: Transformed samples and labels. """ import torch # lgtm [py/repeated-import] lam_i = np.random.uniform(low=self.lam_range[0], high=self.lam_range[1]) delta_i = torch.poisson(input=torch.ones_like(x) * lam_i) / lam_i * self.clip_values[1] return torch.clamp(x + delta_i, min=self.clip_values[0], max=self.clip_values[1]), y
def __call__(self,pic): """ :params pic: input image shaped [...,C,H,W] we assume C = 3 and then we convert it to BW. """ # if pic.max() <= 1: pic *= 255. # print("noise",torch.get_rng_state()) device = pic.device pix_max = 2**self.nbits-1 pic_bw = tvF.rgb_to_grayscale(pic,1) ll_pic = torch.poisson(self.alpha*pic_bw,generator=self.seed) ll_pic += self.read_noise*torch.randn(ll_pic.shape,device=device) if pic.shape[-3] == 3: ll_pic = self._add_color_channel(ll_pic) if self.use_adc: ll_pic = torch.round(ll_pic) ll_pic = torch.clamp(ll_pic, 0, pix_max) ll_pic /= self.alpha return ll_pic
def forward(self, input_irrad_gray): # This function converts the gray values to electrons, applies noise and converts back to gray values if self.generator.device != input_irrad_gray.device: self.generator = torch.Generator(device=input_irrad_gray.device) # todo: store normalization value input_irrad_gray *= self.full_well # Convert gray to photons input_irrad_electrons = input_irrad_gray - self.baseline input_irrad_electrons = input_irrad_electrons / self.sensitivity #* self.full_well / (2**self.bit_depth-1) input_irrad_electrons[input_irrad_electrons < 0] = 0.0 input_irrad_photons = input_irrad_electrons / self.quantum_eff # Add shot noise noisy_image = input_irrad_photons.detach() - torch.poisson( input_irrad_photons.detach(), generator=self.generator) photons = input_irrad_photons + noisy_image # Convert to electrons electrons = self.quantum_eff * photons # Add dark noise electrons_out = torch.normal(mean=0.0, std=self.dark_noise, generator=self.generator) + electrons # Convert to ADU and add baseline max_adu = torch.tensor([2**self.bit_depth - 1], dtype=torch.float32, device=input_irrad_gray.device) adu = (electrons_out * self.sensitivity).float() # Convert to discrete numbers adu += self.baseline adu[adu > max_adu] = max_adu # models pixel saturation return adu / self.full_well
def sample(self, sample_shape=torch.Size()): shape = self._extended_shape(sample_shape) with torch.no_grad(): return torch.poisson(self.rate.expand(shape))
# parser.add_argument('-visdom', '--visdom_flag', action="store_true", help='Whether plotting in visdom is desired') # parser.add_argument('-i-tsne', '--tsne_iter', default=100, type=int, help='epoch when tsne visualization runs') args = parser.parse_args() expn_pth = '/n/data_02/Basset/data/expn/roadmap/57epigenomes.RPKM.pc' print("Reading gene expression data from:\n{}".format(expn_pth)) # Gene expression dataset expn = pd.read_table(expn_pth,header=0) col_names = expn.columns.values[1:] expn = expn.drop(col_names[-1],axis=1) # 19795*57 right now # TODO: is this all right? expn.columns = col_names pinned_lookup = torch.nn.Embedding.from_pretrained(torch.FloatTensor(expn.as_matrix().T[1:]),freeze=True) # [1:] is new! pinned_lookup.cuda() torch.manual_seed(3435) imgs = torch.poisson(pinned_lookup.weight) # discretize data # imgs = pinned_lookup.weight.round() # imgs = pinned_lookup.weight dat = torch.utils.data.TensorDataset(imgs, torch.zeros(56,1)) # placeholder arg required pytorch <0.4.0... loader = torch.utils.data.DataLoader(dat, batch_size=args.batch_size, shuffle=False) print(next(iter(loader))[0].size()) # setup the VAE vae = PyroVAE(latent_dim=args.latent_dim) adam_args = {"lr": args.learning_rate} optimizer = Adam(adam_args) svi = SVI(vae.model, vae.guide, optimizer, loss=Trace_ELBO()) # setup visdom for visualization if args.visdom_flag: vis = visdom.Visdom()